| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_sal.hxx" |
| #include <testshl/simpleheader.hxx> |
| |
| #include <rtl/digest.h> |
| #include <rtl/ustring.hxx> |
| #include <rtl/ustrbuf.hxx> |
| #include <rtl/strbuf.hxx> |
| |
| // sample, how to use digest |
| |
| rtl::OUString CreateMD5FromString( const rtl::OUString& aMsg ) |
| { |
| // PRE: aStr "file" |
| // BACK: Str "ababab....0f" Hexcode String |
| |
| rtlDigest handle = rtl_digest_create( rtl_Digest_AlgorithmMD5 ); |
| if ( handle > 0 ) |
| { |
| const sal_uInt8* pData = (const sal_uInt8*)aMsg.getStr(); |
| sal_uInt32 nSize = ( aMsg.getLength() * sizeof( sal_Unicode )); |
| sal_uInt32 nMD5KeyLen = rtl_digest_queryLength( handle ); |
| sal_uInt8* pMD5KeyBuffer = new sal_uInt8[ nMD5KeyLen ]; |
| |
| rtl_digest_init( handle, pData, nSize ); |
| rtl_digest_update( handle, pData, nSize ); |
| rtl_digest_get( handle, pMD5KeyBuffer, nMD5KeyLen ); |
| rtl_digest_destroy( handle ); |
| |
| // Create hex-value string from the MD5 value to keep the string size minimal |
| rtl::OUStringBuffer aBuffer( nMD5KeyLen * 2 + 1 ); |
| for ( sal_uInt32 i = 0; i < nMD5KeyLen; i++ ) |
| aBuffer.append( (sal_Int32)pMD5KeyBuffer[i], 16 ); |
| |
| delete [] pMD5KeyBuffer; |
| return aBuffer.makeStringAndClear(); |
| } |
| |
| return rtl::OUString(); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| namespace rtl_digest |
| { |
| |
| rtl::OString sSampleString = "This is a sample sentence, which we use to check some crypto functions in sal."; |
| rtl::OString sSampleString_MD2 = "647ee6c9d4aa5fdd374ed9d7a156acbf"; |
| rtl::OString sSampleString_MD5 = "b16b903e6fc0b62ae389013ed93fe531"; |
| rtl::OString sSampleString_SHA = "eab2814429b2613301c8a077b806af3680548914"; |
| rtl::OString sSampleString_SHA1 = "2bc5bdb7506a2cdc2fd27fc8b9889343012d5008"; |
| rtl::OString sSampleString_HMAC_MD5 = "dd9cba48c972fba0a882baa72b079674"; |
| rtl::OString sSampleString_HMAC_SHA1 = "5d7f43ce6abd1de4438d7e69e01495864490cf3e"; |
| |
| rtl::OString sSampleString_only_one_diff = "This is a sample sentence. which we use to check some crypto functions in sal."; |
| |
| class create : public CppUnit::TestFixture |
| { |
| public: |
| // initialise your test code values here. |
| void setUp() |
| { |
| } |
| |
| void tearDown() |
| { |
| } |
| |
| void create_001() |
| { |
| rtlDigest handle = rtl_digest_create( rtl_Digest_AlgorithmMD5 ); |
| CPPUNIT_ASSERT_MESSAGE("create with rtl_Digest_AlgorithmMD5", handle != 0); |
| rtl_digest_destroy( handle ); |
| } |
| void create_002() |
| { |
| rtlDigest handle = rtl_digest_create( rtl_Digest_AlgorithmMD2 ); |
| CPPUNIT_ASSERT_MESSAGE("create with rtl_Digest_AlgorithmMD2", handle != 0); |
| rtl_digest_destroy( handle ); |
| } |
| void create_003() |
| { |
| rtlDigest handle = rtl_digest_create( rtl_Digest_AlgorithmSHA ); |
| CPPUNIT_ASSERT_MESSAGE("create with rtl_Digest_AlgorithmSHA", handle != 0); |
| rtl_digest_destroy( handle ); |
| } |
| void create_004() |
| { |
| rtlDigest handle = rtl_digest_create( rtl_Digest_AlgorithmSHA1 ); |
| CPPUNIT_ASSERT_MESSAGE("create with rtl_Digest_AlgorithmSHA1", handle != 0); |
| rtl_digest_destroy( handle ); |
| } |
| void create_005() |
| { |
| rtlDigest handle = rtl_digest_create( rtl_Digest_AlgorithmHMAC_MD5 ); |
| CPPUNIT_ASSERT_MESSAGE("create with rtl_Digest_AlgorithmHMAC_MD5", handle != 0); |
| rtl_digest_destroy( handle ); |
| } |
| void create_006() |
| { |
| rtlDigest handle = rtl_digest_create( rtl_Digest_AlgorithmHMAC_SHA1 ); |
| CPPUNIT_ASSERT_MESSAGE("create with rtl_Digest_AlgorithmHMAC_SHA1", handle != 0); |
| rtl_digest_destroy( handle ); |
| } |
| |
| void create_007() |
| { |
| rtlDigest handle = rtl_digest_create( rtl_Digest_AlgorithmInvalid ); |
| t_print("Handle is %x\n", handle); |
| CPPUNIT_ASSERT_MESSAGE("create with NULL", handle == 0); |
| rtl_digest_destroy( handle ); |
| } |
| |
| // Change the following lines only, if you add, remove or rename |
| // member functions of the current class, |
| // because these macros are need by auto register mechanism. |
| |
| CPPUNIT_TEST_SUITE(create); |
| CPPUNIT_TEST(create_001); |
| CPPUNIT_TEST(create_002); |
| CPPUNIT_TEST(create_003); |
| CPPUNIT_TEST(create_004); |
| CPPUNIT_TEST(create_005); |
| CPPUNIT_TEST(create_006); |
| CPPUNIT_TEST(create_007); |
| CPPUNIT_TEST_SUITE_END(); |
| }; // class create |
| |
| |
| |
| |
| // ----------------------------------------------------------------------------- |
| |
| class createMD5 : public CppUnit::TestFixture |
| { |
| public: |
| // initialise your test code values here. |
| void setUp() |
| { |
| } |
| |
| void tearDown() |
| { |
| } |
| |
| void createMD5_001() |
| { |
| rtlDigest handle = rtl_digest_createMD5(); |
| |
| rtlDigestAlgorithm aAlgo = rtl_digest_queryAlgorithm(handle); |
| CPPUNIT_ASSERT_MESSAGE("query handle", rtl_Digest_AlgorithmMD5 == aAlgo); |
| |
| rtl_digest_destroy( handle ); |
| } |
| CPPUNIT_TEST_SUITE(createMD5); |
| CPPUNIT_TEST(createMD5_001); |
| CPPUNIT_TEST_SUITE_END(); |
| }; // class create |
| |
| |
| // ----------------------------------------------------------------------------- |
| |
| class createMD2 : public CppUnit::TestFixture |
| { |
| public: |
| // initialise your test code values here. |
| void setUp() |
| { |
| } |
| |
| void tearDown() |
| { |
| } |
| |
| void createMD2_001() |
| { |
| rtlDigest handle = rtl_digest_createMD2( ); |
| |
| rtlDigestAlgorithm aAlgo = rtl_digest_queryAlgorithm(handle); |
| CPPUNIT_ASSERT_MESSAGE("query handle", rtl_Digest_AlgorithmMD2 == aAlgo); |
| |
| rtl_digest_destroy( handle ); |
| } |
| CPPUNIT_TEST_SUITE(createMD2); |
| CPPUNIT_TEST(createMD2_001); |
| CPPUNIT_TEST_SUITE_END(); |
| }; // class create |
| |
| // ----------------------------------------------------------------------------- |
| |
| class createSHA : public CppUnit::TestFixture |
| { |
| public: |
| // initialise your test code values here. |
| void setUp() |
| { |
| } |
| |
| void tearDown() |
| { |
| } |
| |
| void createSHA_001() |
| { |
| rtlDigest handle = rtl_digest_createSHA( ); |
| |
| rtlDigestAlgorithm aAlgo = rtl_digest_queryAlgorithm(handle); |
| CPPUNIT_ASSERT_MESSAGE("query handle", rtl_Digest_AlgorithmSHA == aAlgo); |
| |
| rtl_digest_destroy( handle ); |
| } |
| CPPUNIT_TEST_SUITE(createSHA); |
| CPPUNIT_TEST(createSHA_001); |
| CPPUNIT_TEST_SUITE_END(); |
| }; // class create |
| // ----------------------------------------------------------------------------- |
| |
| class createSHA1 : public CppUnit::TestFixture |
| { |
| public: |
| // initialise your test code values here. |
| void setUp() |
| { |
| } |
| |
| void tearDown() |
| { |
| } |
| |
| void createSHA1_001() |
| { |
| rtlDigest handle = rtl_digest_createSHA1(); |
| |
| rtlDigestAlgorithm aAlgo = rtl_digest_queryAlgorithm(handle); |
| CPPUNIT_ASSERT_MESSAGE("query handle", rtl_Digest_AlgorithmSHA1 == aAlgo); |
| |
| rtl_digest_destroy( handle ); |
| } |
| CPPUNIT_TEST_SUITE(createSHA1); |
| CPPUNIT_TEST(createSHA1_001); |
| CPPUNIT_TEST_SUITE_END(); |
| }; // class create |
| // ----------------------------------------------------------------------------- |
| |
| class createHMAC_MD5 : public CppUnit::TestFixture |
| { |
| public: |
| // initialise your test code values here. |
| void setUp() |
| { |
| } |
| |
| void tearDown() |
| { |
| } |
| |
| void createHMAC_MD5_001() |
| { |
| rtlDigest handle = rtl_digest_createHMAC_MD5(); |
| |
| rtlDigestAlgorithm aAlgo = rtl_digest_queryAlgorithm(handle); |
| CPPUNIT_ASSERT_MESSAGE("query handle", rtl_Digest_AlgorithmHMAC_MD5 == aAlgo); |
| |
| rtl_digest_destroy( handle ); |
| } |
| CPPUNIT_TEST_SUITE(createHMAC_MD5); |
| CPPUNIT_TEST(createHMAC_MD5_001); |
| CPPUNIT_TEST_SUITE_END(); |
| }; // class create |
| // ----------------------------------------------------------------------------- |
| |
| class createHMAC_SHA1 : public CppUnit::TestFixture |
| { |
| public: |
| // initialise your test code values here. |
| void setUp() |
| { |
| } |
| |
| void tearDown() |
| { |
| } |
| |
| void createHMAC_SHA1_001() |
| { |
| rtlDigest handle = rtl_digest_createHMAC_SHA1(); |
| |
| rtlDigestAlgorithm aAlgo = rtl_digest_queryAlgorithm(handle); |
| CPPUNIT_ASSERT_MESSAGE("query handle", rtl_Digest_AlgorithmHMAC_SHA1 == aAlgo); |
| |
| rtl_digest_destroy( handle ); |
| } |
| |
| |
| CPPUNIT_TEST_SUITE(createHMAC_SHA1); |
| CPPUNIT_TEST(createHMAC_SHA1_001); |
| CPPUNIT_TEST_SUITE_END(); |
| }; // class create |
| |
| // ----------------------------------------------------------------------------- |
| |
| class queryAlgorithm : public CppUnit::TestFixture |
| { |
| public: |
| // initialise your test code values here. |
| void setUp() |
| { |
| } |
| |
| void tearDown() |
| { |
| } |
| |
| void query_001() |
| { |
| rtlDigest handle = rtl_digest_create( rtl_Digest_AlgorithmMD5 ); |
| |
| rtlDigestAlgorithm aAlgo = rtl_digest_queryAlgorithm(handle); |
| CPPUNIT_ASSERT_MESSAGE("query handle", rtl_Digest_AlgorithmMD5 == aAlgo); |
| |
| rtl_digest_destroy( handle ); |
| } |
| void query_002() |
| { |
| rtlDigest handle = rtl_digest_create( rtl_Digest_AlgorithmMD2 ); |
| |
| rtlDigestAlgorithm aAlgo = rtl_digest_queryAlgorithm(handle); |
| CPPUNIT_ASSERT_MESSAGE("query handle", rtl_Digest_AlgorithmMD2 == aAlgo); |
| |
| rtl_digest_destroy( handle ); |
| } |
| void query_003() |
| { |
| rtlDigest handle = rtl_digest_create( rtl_Digest_AlgorithmSHA ); |
| |
| rtlDigestAlgorithm aAlgo = rtl_digest_queryAlgorithm(handle); |
| CPPUNIT_ASSERT_MESSAGE("query handle", rtl_Digest_AlgorithmSHA == aAlgo); |
| |
| rtl_digest_destroy( handle ); |
| } |
| void query_004() |
| { |
| rtlDigest handle = rtl_digest_create( rtl_Digest_AlgorithmSHA1 ); |
| |
| rtlDigestAlgorithm aAlgo = rtl_digest_queryAlgorithm(handle); |
| CPPUNIT_ASSERT_MESSAGE("query handle", rtl_Digest_AlgorithmSHA1 == aAlgo); |
| |
| rtl_digest_destroy( handle ); |
| } |
| void query_005() |
| { |
| rtlDigest handle = rtl_digest_create( rtl_Digest_AlgorithmHMAC_MD5 ); |
| |
| rtlDigestAlgorithm aAlgo = rtl_digest_queryAlgorithm(handle); |
| CPPUNIT_ASSERT_MESSAGE("query handle", rtl_Digest_AlgorithmHMAC_MD5 == aAlgo); |
| |
| rtl_digest_destroy( handle ); |
| } |
| void query_006() |
| { |
| rtlDigest handle = rtl_digest_create( rtl_Digest_AlgorithmHMAC_SHA1 ); |
| |
| rtlDigestAlgorithm aAlgo = rtl_digest_queryAlgorithm(handle); |
| CPPUNIT_ASSERT_MESSAGE("query handle", rtl_Digest_AlgorithmHMAC_SHA1 == aAlgo); |
| |
| rtl_digest_destroy( handle ); |
| } |
| void query_007() |
| { |
| rtlDigest handle = rtl_digest_create( rtl_Digest_AlgorithmInvalid ); |
| |
| rtlDigestAlgorithm aAlgo = rtl_digest_queryAlgorithm(handle); |
| CPPUNIT_ASSERT_MESSAGE("query handle", rtl_Digest_AlgorithmInvalid == aAlgo); |
| |
| rtl_digest_destroy( handle ); |
| } |
| |
| // Change the following lines only, if you add, remove or rename |
| // member functions of the current class, |
| // because these macros are need by auto register mechanism. |
| |
| CPPUNIT_TEST_SUITE(queryAlgorithm); |
| CPPUNIT_TEST( query_001 ); |
| CPPUNIT_TEST( query_002 ); |
| CPPUNIT_TEST( query_003 ); |
| CPPUNIT_TEST( query_004 ); |
| CPPUNIT_TEST( query_005 ); |
| CPPUNIT_TEST( query_006 ); |
| CPPUNIT_TEST( query_007 ); |
| CPPUNIT_TEST_SUITE_END(); |
| }; // class create |
| |
| |
| // ----------------------------------------------------------------------------- |
| class queryLength : public CppUnit::TestFixture |
| { |
| public: |
| // initialise your test code values here. |
| void setUp() |
| { |
| } |
| |
| void tearDown() |
| { |
| } |
| |
| void queryLength_MD5() |
| { |
| rtlDigest handle = rtl_digest_create( rtl_Digest_AlgorithmMD5 ); |
| |
| sal_uInt32 nAlgoLength = rtl_digest_queryLength(handle); |
| // t_print("nAlgoLength:=%d\n", nAlgoLength); |
| CPPUNIT_ASSERT_MESSAGE("query Length", RTL_DIGEST_LENGTH_MD5 == nAlgoLength); |
| |
| rtl_digest_destroy( handle ); |
| } |
| void queryLength_MD2() |
| { |
| rtlDigest handle = rtl_digest_create( rtl_Digest_AlgorithmMD2 ); |
| |
| sal_uInt32 nAlgoLength = rtl_digest_queryLength(handle); |
| // t_print("nAlgoLength:=%d\n", nAlgoLength); |
| CPPUNIT_ASSERT_MESSAGE("query length", RTL_DIGEST_LENGTH_MD2 == nAlgoLength); |
| |
| rtl_digest_destroy( handle ); |
| } |
| void queryLength_SHA() |
| { |
| rtlDigest handle = rtl_digest_create( rtl_Digest_AlgorithmSHA ); |
| |
| sal_uInt32 nAlgoLength = rtl_digest_queryLength(handle); |
| // t_print("nAlgoLength:=%d\n", nAlgoLength); |
| CPPUNIT_ASSERT_MESSAGE("query length", RTL_DIGEST_LENGTH_SHA == nAlgoLength); |
| |
| rtl_digest_destroy( handle ); |
| } |
| void queryLength_SHA1() |
| { |
| rtlDigest handle = rtl_digest_create( rtl_Digest_AlgorithmSHA1 ); |
| |
| sal_uInt32 nAlgoLength = rtl_digest_queryLength(handle); |
| // t_print("nAlgoLength:=%d\n", nAlgoLength); |
| CPPUNIT_ASSERT_MESSAGE("query length", RTL_DIGEST_LENGTH_SHA1 == nAlgoLength); |
| |
| rtl_digest_destroy( handle ); |
| } |
| void queryLength_HMAC_MD5() |
| { |
| rtlDigest handle = rtl_digest_create( rtl_Digest_AlgorithmHMAC_MD5 ); |
| |
| sal_uInt32 nAlgoLength = rtl_digest_queryLength(handle); |
| // t_print("nAlgoLength:=%d\n", nAlgoLength); |
| CPPUNIT_ASSERT_MESSAGE("query length", RTL_DIGEST_LENGTH_HMAC_MD5 == nAlgoLength); |
| |
| rtl_digest_destroy( handle ); |
| } |
| void queryLength_HMAC_SHA1() |
| { |
| rtlDigest handle = rtl_digest_create( rtl_Digest_AlgorithmHMAC_SHA1 ); |
| |
| sal_uInt32 nAlgoLength = rtl_digest_queryLength(handle); |
| // t_print("nAlgoLength:=%d\n", nAlgoLength); |
| CPPUNIT_ASSERT_MESSAGE("query length", RTL_DIGEST_LENGTH_HMAC_SHA1 == nAlgoLength); |
| |
| rtl_digest_destroy( handle ); |
| } |
| |
| void queryLength_Illegal() |
| { |
| rtlDigest handle = rtl_digest_create( rtl_Digest_AlgorithmInvalid ); |
| |
| sal_uInt32 nAlgoLength = rtl_digest_queryLength(handle); |
| // t_print("nAlgoLength:=%d\n", nAlgoLength); |
| CPPUNIT_ASSERT_MESSAGE("query length", 0 == nAlgoLength); |
| |
| rtl_digest_destroy( handle ); |
| } |
| |
| // Change the following lines only, if you add, remove or rename |
| // member functions of the current class, |
| // because these macros are need by auto register mechanism. |
| |
| CPPUNIT_TEST_SUITE(queryLength); |
| CPPUNIT_TEST( queryLength_MD2 ); |
| CPPUNIT_TEST( queryLength_MD5 ); |
| CPPUNIT_TEST( queryLength_SHA ); |
| CPPUNIT_TEST( queryLength_SHA1 ); |
| CPPUNIT_TEST( queryLength_HMAC_MD5 ); |
| CPPUNIT_TEST( queryLength_HMAC_SHA1 ); |
| CPPUNIT_TEST( queryLength_Illegal ); |
| CPPUNIT_TEST_SUITE_END(); |
| }; // class create |
| |
| // ----------------------------------------------------------------------------- |
| |
| rtl::OString createHex(sal_uInt8 *_pMD5KeyBuffer, sal_uInt32 _nMD5KeyLen) |
| { |
| // Create hex-value string from the MD5 value to keep the string size minimal |
| rtl::OStringBuffer aBuffer( _nMD5KeyLen * 2 + 1 ); |
| for ( sal_uInt32 i = 0; i < _nMD5KeyLen; i++ ) |
| { |
| sal_Int32 nValue = (sal_Int32)_pMD5KeyBuffer[i]; |
| if (nValue < 16) // maximul hex value for 1 byte |
| { |
| aBuffer.append( sal_Int32(0), 16 /* radix */ ); |
| } |
| aBuffer.append( nValue, 16 /* radix */ ); |
| } |
| |
| return aBuffer.makeStringAndClear(); |
| } |
| |
| |
| // ----------------------------------------------------------------------------- |
| class init : public CppUnit::TestFixture |
| { |
| public: |
| // initialise your test code values here. |
| void setUp() |
| { |
| } |
| |
| void tearDown() |
| { |
| } |
| |
| void init_000() |
| { |
| rtlDigest handle = NULL; |
| |
| rtlDigestError aError = rtl_digest_init(handle, NULL, 0); |
| |
| CPPUNIT_ASSERT_MESSAGE("init(NULL, 0, 0)", aError == rtl_Digest_E_Argument); |
| } |
| |
| void init_001() |
| { |
| rtlDigest handle = rtl_digest_create( rtl_Digest_AlgorithmMD5 ); |
| |
| rtlDigestError aError = rtl_digest_init(handle, NULL, 0); |
| |
| CPPUNIT_ASSERT_MESSAGE("init(handle, 0, 0)", aError == rtl_Digest_E_None); |
| |
| rtl_digest_destroy( handle ); |
| } |
| |
| // ------------------------------------ |
| void init_MD2() |
| { |
| rtlDigest handle = rtl_digest_create( rtl_Digest_AlgorithmMD2 ); |
| |
| rtl::OString aMsg = sSampleString; |
| const sal_uInt8 *pData = (const sal_uInt8*)aMsg.getStr(); |
| sal_uInt32 nSize = ( aMsg.getLength() ); |
| |
| rtlDigestError aError = rtl_digest_init(handle, pData, nSize); |
| |
| CPPUNIT_ASSERT_MESSAGE("init(handle, pData, nSize)", aError == rtl_Digest_E_None); |
| |
| rtl_digest_update( handle, pData, nSize ); |
| |
| sal_uInt32 nKeyLen = rtl_digest_queryLength( handle ); |
| sal_uInt8 *pKeyBuffer = new sal_uInt8[ nKeyLen ]; |
| |
| rtl_digest_get( handle, pKeyBuffer, nKeyLen ); |
| rtl::OString aSum = createHex(pKeyBuffer, nKeyLen); |
| delete [] pKeyBuffer; |
| |
| t_print("MD2 Sum: %s\n", aSum.getStr()); |
| // LLA: how to check right values |
| // samples? |
| |
| rtl_digest_destroy( handle ); |
| } |
| |
| void init_MD5() |
| { |
| rtlDigest handle = rtl_digest_create( rtl_Digest_AlgorithmMD5 ); |
| |
| rtl::OString aMsg = sSampleString; |
| const sal_uInt8 *pData = (const sal_uInt8*)aMsg.getStr(); |
| sal_uInt32 nSize = ( aMsg.getLength() ); |
| |
| rtlDigestError aError = rtl_digest_init(handle, pData, nSize); |
| |
| CPPUNIT_ASSERT_MESSAGE("init(handle, pData, nSize)", aError == rtl_Digest_E_None); |
| |
| rtl_digest_update( handle, pData, nSize ); |
| |
| sal_uInt32 nKeyLen = rtl_digest_queryLength( handle ); |
| sal_uInt8 *pKeyBuffer = new sal_uInt8[ nKeyLen ]; |
| |
| rtl_digest_get( handle, pKeyBuffer, nKeyLen ); |
| rtl::OString aSum = createHex(pKeyBuffer, nKeyLen); |
| delete [] pKeyBuffer; |
| |
| t_print("MD5 Sum: %s\n", aSum.getStr()); |
| // LLA: how to check right values |
| // samples? |
| |
| rtl_digest_destroy( handle ); |
| } |
| |
| void init_SHA() |
| { |
| rtlDigest handle = rtl_digest_create( rtl_Digest_AlgorithmSHA ); |
| |
| rtl::OString aMsg = sSampleString; |
| const sal_uInt8 *pData = (const sal_uInt8*)aMsg.getStr(); |
| sal_uInt32 nSize = ( aMsg.getLength() ); |
| |
| rtlDigestError aError = rtl_digest_init(handle, pData, nSize); |
| |
| CPPUNIT_ASSERT_MESSAGE("init(handle, pData, nSize)", aError == rtl_Digest_E_None); |
| |
| rtl_digest_update( handle, pData, nSize ); |
| |
| sal_uInt32 nKeyLen = rtl_digest_queryLength( handle ); |
| sal_uInt8 *pKeyBuffer = new sal_uInt8[ nKeyLen ]; |
| |
| rtl_digest_get( handle, pKeyBuffer, nKeyLen ); |
| rtl::OString aSum = createHex(pKeyBuffer, nKeyLen); |
| delete [] pKeyBuffer; |
| |
| t_print("SHA Sum: %s\n", aSum.getStr()); |
| // LLA: how to check right values |
| // samples? |
| |
| rtl_digest_destroy( handle ); |
| } |
| void init_SHA1() |
| { |
| rtlDigest handle = rtl_digest_create( rtl_Digest_AlgorithmSHA1 ); |
| |
| rtl::OString aMsg = sSampleString; |
| const sal_uInt8 *pData = (const sal_uInt8*)aMsg.getStr(); |
| sal_uInt32 nSize = ( aMsg.getLength() ); |
| |
| rtlDigestError aError = rtl_digest_init(handle, pData, nSize); |
| |
| CPPUNIT_ASSERT_MESSAGE("init(handle, pData, nSize)", aError == rtl_Digest_E_None); |
| |
| rtl_digest_update( handle, pData, nSize ); |
| |
| sal_uInt32 nKeyLen = rtl_digest_queryLength( handle ); |
| sal_uInt8 *pKeyBuffer = new sal_uInt8[ nKeyLen ]; |
| |
| rtl_digest_get( handle, pKeyBuffer, nKeyLen ); |
| rtl::OString aSum = createHex(pKeyBuffer, nKeyLen); |
| delete [] pKeyBuffer; |
| |
| t_print("SHA1 Sum: %s\n", aSum.getStr()); |
| // LLA: how to check right values |
| // samples? |
| |
| rtl_digest_destroy( handle ); |
| } |
| void init_HMAC_MD5() |
| { |
| rtlDigest handle = rtl_digest_create( rtl_Digest_AlgorithmHMAC_MD5 ); |
| |
| rtl::OString aMsg = sSampleString; |
| const sal_uInt8 *pData = (const sal_uInt8*)aMsg.getStr(); |
| sal_uInt32 nSize = ( aMsg.getLength() ); |
| |
| sal_uInt32 nKeyLen = rtl_digest_queryLength( handle ); |
| CPPUNIT_ASSERT_MESSAGE( "Keylen must be greater 0", nKeyLen ); |
| |
| sal_uInt8 *pKeyBuffer = new sal_uInt8[ nKeyLen ]; |
| CPPUNIT_ASSERT( pKeyBuffer ); |
| memset(pKeyBuffer, 0, nKeyLen); |
| |
| rtlDigestError aError = rtl_digest_init(handle, pKeyBuffer, nKeyLen ); |
| |
| CPPUNIT_ASSERT_MESSAGE("init(handle, pData, nSize)", aError == rtl_Digest_E_None); |
| |
| rtl_digest_update( handle, pData, nSize ); |
| |
| rtl_digest_get( handle, pKeyBuffer, nKeyLen ); |
| rtl::OString aSum = createHex(pKeyBuffer, nKeyLen); |
| delete [] pKeyBuffer; |
| |
| t_print("HMAC_MD5 Sum: %s\n", aSum.getStr()); |
| // LLA: how to check right values |
| // samples? |
| |
| rtl_digest_destroy( handle ); |
| } |
| void init_HMAC_SHA1() |
| { |
| rtlDigest handle = rtl_digest_create( rtl_Digest_AlgorithmHMAC_SHA1 ); |
| |
| rtl::OString aMsg = sSampleString; |
| const sal_uInt8 *pData = (const sal_uInt8*)aMsg.getStr(); |
| sal_uInt32 nSize = ( aMsg.getLength() ); |
| |
| sal_uInt32 nKeyLen = rtl_digest_queryLength( handle ); |
| CPPUNIT_ASSERT_MESSAGE( "Keylen must be greater 0", nKeyLen ); |
| |
| sal_uInt8 *pKeyBuffer = new sal_uInt8[ nKeyLen ]; |
| CPPUNIT_ASSERT( pKeyBuffer ); |
| memset(pKeyBuffer, 0, nKeyLen); |
| |
| rtlDigestError aError = rtl_digest_init(handle, pKeyBuffer, nKeyLen ); |
| |
| CPPUNIT_ASSERT_MESSAGE("init(handle, pData, nSize)", aError == rtl_Digest_E_None); |
| |
| rtl_digest_update( handle, pData, nSize ); |
| |
| rtl_digest_get( handle, pKeyBuffer, nKeyLen ); |
| rtl::OString aSum = createHex(pKeyBuffer, nKeyLen); |
| delete [] pKeyBuffer; |
| |
| t_print("HMAC_SHA1 Sum: %s\n", aSum.getStr()); |
| // LLA: how to check right values |
| // samples? |
| |
| rtl_digest_destroy( handle ); |
| } |
| |
| |
| // Change the following lines only, if you add, remove or rename |
| // member functions of the current class, |
| // because these macros are need by auto register mechanism. |
| |
| CPPUNIT_TEST_SUITE(init); |
| CPPUNIT_TEST( init_000 ); |
| CPPUNIT_TEST( init_001 ); |
| CPPUNIT_TEST( init_MD2 ); |
| CPPUNIT_TEST( init_MD5 ); |
| CPPUNIT_TEST( init_SHA ); |
| CPPUNIT_TEST( init_SHA1 ); |
| CPPUNIT_TEST( init_HMAC_MD5 ); |
| CPPUNIT_TEST( init_HMAC_SHA1 ); |
| CPPUNIT_TEST_SUITE_END(); |
| }; // class init |
| |
| // ------------------------------------ |
| |
| rtl::OString getMD5Sum(rtl::OString const& _aMsg ) |
| { |
| rtlDigest handle = rtl_digest_create( rtl_Digest_AlgorithmMD5 ); |
| |
| const sal_uInt8 *pData = (const sal_uInt8*)_aMsg.getStr(); |
| sal_uInt32 nSize = ( _aMsg.getLength() ); |
| |
| rtl_digest_init(handle, pData, nSize); |
| rtl_digest_update( handle, pData, nSize ); |
| |
| sal_uInt32 nMD5KeyLen = rtl_digest_queryLength( handle ); |
| sal_uInt8 *pMD5KeyBuffer = new sal_uInt8[ nMD5KeyLen ]; |
| |
| rtl_digest_get( handle, pMD5KeyBuffer, nMD5KeyLen ); |
| rtl::OString aMD5Sum = createHex(pMD5KeyBuffer, nMD5KeyLen); |
| delete [] pMD5KeyBuffer; |
| |
| rtl_digest_destroy( handle ); |
| return aMD5Sum; |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| class equalTests : public CppUnit::TestFixture |
| { |
| public: |
| // initialise your test code values here. |
| void setUp() |
| { |
| } |
| |
| void tearDown() |
| { |
| } |
| |
| // ------------------------------------ |
| void equal_001() |
| { |
| rtl::OString aMsg1 = sSampleString; |
| rtl::OString aMsg2 = sSampleString; |
| |
| rtl::OString aMsgMD5Sum1 = getMD5Sum(aMsg1); |
| rtl::OString aMsgMD5Sum2 = getMD5Sum(aMsg2); |
| |
| CPPUNIT_ASSERT_MESSAGE("md5sum must have a length", aMsgMD5Sum1.getLength() == 32 && aMsgMD5Sum2.getLength() == 32 ); |
| CPPUNIT_ASSERT_MESSAGE("source is the same, dest must be also the same", aMsgMD5Sum1.equals(aMsgMD5Sum2) == sal_True); |
| } |
| // ------------------------------------ |
| void equal_002() |
| { |
| rtl::OString aMsg1 = sSampleString; |
| rtl::OString aMsg2 = sSampleString_only_one_diff; |
| |
| rtl::OString aMsgMD5Sum1 = getMD5Sum(aMsg1); |
| rtl::OString aMsgMD5Sum2 = getMD5Sum(aMsg2); |
| |
| CPPUNIT_ASSERT_MESSAGE("md5sum must have a length", aMsgMD5Sum1.getLength() == 32 && aMsgMD5Sum2.getLength() == 32 ); |
| CPPUNIT_ASSERT_MESSAGE("differ only in one char", aMsgMD5Sum1.equals(aMsgMD5Sum2) == sal_False); |
| } |
| |
| // Change the following lines only, if you add, remove or rename |
| // member functions of the current class, |
| // because these macros are need by auto register mechanism. |
| |
| CPPUNIT_TEST_SUITE(equalTests); |
| CPPUNIT_TEST( equal_001 ); |
| CPPUNIT_TEST( equal_002 ); |
| CPPUNIT_TEST_SUITE_END(); |
| }; // class create |
| |
| |
| // ----------------------------------------------------------------------------- |
| class digest_MD2 : public CppUnit::TestFixture |
| { |
| public: |
| // initialise your test code values here. |
| void setUp() |
| { |
| } |
| |
| void tearDown() |
| { |
| } |
| |
| // ------------------------------------ |
| void MD2_001() |
| { |
| rtl::OString aMsg1 = sSampleString; |
| |
| sal_uInt8 *pBuffer = new sal_uInt8[ RTL_DIGEST_LENGTH_MD2 ]; |
| CPPUNIT_ASSERT( pBuffer ); |
| memset(pBuffer, 0, RTL_DIGEST_LENGTH_MD2 ); |
| |
| sal_uInt8 *pMsg1 = (sal_uInt8*)aMsg1.getStr(); |
| sal_Int32 nLen = aMsg1.getLength(); |
| |
| rtlDigestError aError = rtl_digest_MD2(pMsg1, nLen, pBuffer, RTL_DIGEST_LENGTH_MD2); |
| |
| CPPUNIT_ASSERT(aError == rtl_Digest_E_None ); |
| |
| rtl::OString aStr = createHex(pBuffer, RTL_DIGEST_LENGTH_MD2); |
| t_print("Decrypt MD2: %s\n", aStr.getStr()); |
| CPPUNIT_ASSERT_MESSAGE("checksum of sample string is wrong. Code changes or sample problems, please check.", aStr.equals(sSampleString_MD2) ); |
| |
| delete [] pBuffer; |
| } |
| |
| // Change the following lines only, if you add, remove or rename |
| // member functions of the current class, |
| // because these macros are need by auto register mechanism. |
| |
| CPPUNIT_TEST_SUITE(digest_MD2); |
| CPPUNIT_TEST( MD2_001 ); |
| CPPUNIT_TEST_SUITE_END(); |
| }; // class create |
| // ----------------------------------------------------------------------------- |
| class digest_MD5 : public CppUnit::TestFixture |
| { |
| public: |
| // initialise your test code values here. |
| void setUp() |
| { |
| } |
| |
| void tearDown() |
| { |
| } |
| // ------------------------------------ |
| void MD5_001() |
| { |
| rtl::OString aMsg1 = sSampleString; |
| |
| sal_uInt8 *pBuffer = new sal_uInt8[ RTL_DIGEST_LENGTH_MD5 ]; |
| CPPUNIT_ASSERT( pBuffer ); |
| memset(pBuffer, 0, RTL_DIGEST_LENGTH_MD5 ); |
| |
| sal_uInt8 *pMsg1 = (sal_uInt8*)aMsg1.getStr(); |
| sal_Int32 nLen = aMsg1.getLength(); |
| |
| rtlDigestError aError = rtl_digest_MD5(pMsg1, nLen, pBuffer, RTL_DIGEST_LENGTH_MD5); |
| |
| CPPUNIT_ASSERT(aError == rtl_Digest_E_None ); |
| |
| rtl::OString aStr = createHex(pBuffer, RTL_DIGEST_LENGTH_MD5); |
| t_print("Decrypt MD5: %s\n", aStr.getStr()); |
| CPPUNIT_ASSERT_MESSAGE("checksum of sample string is wrong. Code changes or sample problems, please check.", aStr.equals(sSampleString_MD5) ); |
| |
| delete [] pBuffer; |
| } |
| |
| // Change the following lines only, if you add, remove or rename |
| // member functions of the current class, |
| // because these macros are need by auto register mechanism. |
| |
| CPPUNIT_TEST_SUITE(digest_MD5); |
| CPPUNIT_TEST( MD5_001 ); |
| CPPUNIT_TEST_SUITE_END(); |
| }; // class create |
| |
| // ----------------------------------------------------------------------------- |
| class digest_SHA : public CppUnit::TestFixture |
| { |
| public: |
| // initialise your test code values here. |
| void setUp() |
| { |
| } |
| |
| void tearDown() |
| { |
| } |
| |
| // ------------------------------------ |
| void SHA_001() |
| { |
| rtl::OString aMsg1 = sSampleString; |
| |
| sal_uInt8 *pBuffer = new sal_uInt8[ RTL_DIGEST_LENGTH_SHA ]; |
| CPPUNIT_ASSERT( pBuffer ); |
| memset(pBuffer, 0, RTL_DIGEST_LENGTH_SHA); |
| |
| sal_uInt8 *pMsg1 = (sal_uInt8*)aMsg1.getStr(); |
| sal_Int32 nLen = aMsg1.getLength(); |
| |
| rtlDigestError aError = rtl_digest_SHA(pMsg1, nLen, pBuffer, RTL_DIGEST_LENGTH_SHA); |
| |
| CPPUNIT_ASSERT(aError == rtl_Digest_E_None ); |
| |
| rtl::OString aStr = createHex(pBuffer, RTL_DIGEST_LENGTH_SHA); |
| t_print("Decrypt SHA: %s\n", aStr.getStr()); |
| CPPUNIT_ASSERT_MESSAGE("checksum of sample string is wrong. Code changes or sample problems, please check.", aStr.equals(sSampleString_SHA) ); |
| |
| delete [] pBuffer; |
| } |
| |
| // Change the following lines only, if you add, remove or rename |
| // member functions of the current class, |
| // because these macros are need by auto register mechanism. |
| |
| CPPUNIT_TEST_SUITE(digest_SHA); |
| CPPUNIT_TEST( SHA_001 ); |
| CPPUNIT_TEST_SUITE_END(); |
| }; // class create |
| |
| // ----------------------------------------------------------------------------- |
| class digest_SHA1 : public CppUnit::TestFixture |
| { |
| public: |
| // initialise your test code values here. |
| void setUp() |
| { |
| } |
| |
| void tearDown() |
| { |
| } |
| |
| // ------------------------------------ |
| void SHA1_001() |
| { |
| rtl::OString aMsg1 = sSampleString; |
| |
| sal_uInt8 *pBuffer = new sal_uInt8[ RTL_DIGEST_LENGTH_SHA1 ]; |
| CPPUNIT_ASSERT( pBuffer ); |
| memset(pBuffer, 0, RTL_DIGEST_LENGTH_SHA1); |
| |
| sal_uInt8 *pMsg1 = (sal_uInt8*)aMsg1.getStr(); |
| sal_Int32 nLen = aMsg1.getLength(); |
| |
| rtlDigestError aError = rtl_digest_SHA1(pMsg1, nLen, pBuffer, RTL_DIGEST_LENGTH_SHA1); |
| |
| CPPUNIT_ASSERT(aError == rtl_Digest_E_None ); |
| |
| rtl::OString aStr = createHex(pBuffer, RTL_DIGEST_LENGTH_SHA1); |
| t_print("Decrypt SHA1: %s\n", aStr.getStr()); |
| CPPUNIT_ASSERT_MESSAGE("checksum of sample string is wrong. Code changes or sample problems, please check.", aStr.equals(sSampleString_SHA1) ); |
| |
| delete [] pBuffer; |
| } |
| // Change the following lines only, if you add, remove or rename |
| // member functions of the current class, |
| // because these macros are need by auto register mechanism. |
| |
| CPPUNIT_TEST_SUITE(digest_SHA1); |
| CPPUNIT_TEST( SHA1_001 ); |
| CPPUNIT_TEST_SUITE_END(); |
| }; // class create |
| // ----------------------------------------------------------------------------- |
| class digest_HMAC_MD5 : public CppUnit::TestFixture |
| { |
| public: |
| // initialise your test code values here. |
| void setUp() |
| { |
| } |
| |
| void tearDown() |
| { |
| } |
| |
| // ------------------------------------ |
| void HMAC_MD5_001() |
| { |
| rtl::OString aMsg1 = sSampleString; |
| |
| sal_uInt8 *pKeyBuffer = new sal_uInt8[ RTL_DIGEST_LENGTH_HMAC_MD5 ]; |
| CPPUNIT_ASSERT( pKeyBuffer ); |
| memset(pKeyBuffer, 0, RTL_DIGEST_LENGTH_HMAC_MD5); |
| |
| sal_uInt8 *pBuffer = new sal_uInt8[ RTL_DIGEST_LENGTH_HMAC_MD5 ]; |
| CPPUNIT_ASSERT( pBuffer ); |
| memset(pBuffer, 0, RTL_DIGEST_LENGTH_HMAC_MD5); |
| |
| sal_uInt8 *pMsg1 = (sal_uInt8*)aMsg1.getStr(); |
| sal_Int32 nLen = aMsg1.getLength(); |
| |
| rtlDigestError aError = rtl_digest_HMAC_MD5(pKeyBuffer, RTL_DIGEST_LENGTH_HMAC_MD5, pMsg1, nLen, pBuffer, RTL_DIGEST_LENGTH_HMAC_MD5); |
| |
| CPPUNIT_ASSERT(aError == rtl_Digest_E_None ); |
| |
| rtl::OString aStr = createHex(pBuffer, RTL_DIGEST_LENGTH_HMAC_MD5); |
| t_print("Decrypt HMAC_MD5: %s\n", aStr.getStr()); |
| CPPUNIT_ASSERT_MESSAGE("md5sum of sample string is wrong. Code changes or sample problems, please check.", aStr.equals(sSampleString_HMAC_MD5) ); |
| |
| delete [] pBuffer; |
| } |
| // Change the following lines only, if you add, remove or rename |
| // member functions of the current class, |
| // because these macros are need by auto register mechanism. |
| |
| CPPUNIT_TEST_SUITE(digest_HMAC_MD5); |
| CPPUNIT_TEST( HMAC_MD5_001 ); |
| CPPUNIT_TEST_SUITE_END(); |
| }; // class create |
| // ----------------------------------------------------------------------------- |
| class digest_HMAC_SHA1 : public CppUnit::TestFixture |
| { |
| public: |
| // initialise your test code values here. |
| void setUp() |
| { |
| } |
| |
| void tearDown() |
| { |
| } |
| |
| // ------------------------------------ |
| void HMAC_SHA1_001() |
| { |
| rtl::OString aMsg1 = sSampleString; |
| |
| sal_uInt8 *pKeyBuffer = new sal_uInt8[ RTL_DIGEST_LENGTH_HMAC_SHA1 ]; |
| CPPUNIT_ASSERT( pKeyBuffer ); |
| memset(pKeyBuffer, 0, RTL_DIGEST_LENGTH_HMAC_SHA1); |
| |
| sal_uInt8 *pBuffer = new sal_uInt8[ RTL_DIGEST_LENGTH_HMAC_SHA1 ]; |
| CPPUNIT_ASSERT( pBuffer ); |
| memset(pBuffer, 0, RTL_DIGEST_LENGTH_HMAC_SHA1); |
| |
| sal_uInt8 *pMsg1 = (sal_uInt8*)aMsg1.getStr(); |
| sal_Int32 nLen = aMsg1.getLength(); |
| |
| rtlDigestError aError = rtl_digest_HMAC_SHA1(pKeyBuffer, RTL_DIGEST_LENGTH_HMAC_SHA1, pMsg1, nLen, pBuffer, RTL_DIGEST_LENGTH_HMAC_SHA1); |
| |
| CPPUNIT_ASSERT(aError == rtl_Digest_E_None ); |
| |
| rtl::OString aStr = createHex(pBuffer, RTL_DIGEST_LENGTH_HMAC_SHA1); |
| t_print("Decrypt HMAC_SHA1: %s\n", aStr.getStr()); |
| CPPUNIT_ASSERT_MESSAGE("md5sum of sample string is wrong. Code changes or sample problems, please check.", aStr.equals(sSampleString_HMAC_SHA1) ); |
| |
| delete [] pBuffer; |
| } |
| |
| // Change the following lines only, if you add, remove or rename |
| // member functions of the current class, |
| // because these macros are need by auto register mechanism. |
| |
| CPPUNIT_TEST_SUITE(digest_HMAC_SHA1); |
| CPPUNIT_TEST( HMAC_SHA1_001 ); |
| CPPUNIT_TEST_SUITE_END(); |
| }; // class create |
| // ----------------------------------------------------------------------------- |
| class digest_PBKDF2 : public CppUnit::TestFixture |
| { |
| public: |
| // initialise your test code values here. |
| void setUp() |
| { |
| } |
| |
| void tearDown() |
| { |
| } |
| |
| // ------------------------------------ |
| rtl::OString /* key */ run_check_PBKDF2(rtl::OString const& _sPassword, bool _bClearSalt, sal_uInt32 _nCount) |
| { |
| sal_uInt32 nKeyLen = RTL_DIGEST_LENGTH_HMAC_SHA1; |
| sal_uInt8 *pKeyBuffer = new sal_uInt8[ nKeyLen ]; |
| CPPUNIT_ASSERT( pKeyBuffer ); |
| memset(pKeyBuffer, 0, nKeyLen); |
| |
| sal_uInt8 *pPassword = (sal_uInt8*)_sPassword.getStr(); |
| sal_Int32 nPasswordLen = _sPassword.getLength(); |
| |
| sal_uInt32 nSaltDataLen = RTL_DIGEST_LENGTH_HMAC_SHA1; |
| sal_uInt8 *pSaltData = new sal_uInt8[ nSaltDataLen ]; |
| CPPUNIT_ASSERT( pSaltData ); |
| memset(pSaltData, 0, nSaltDataLen); |
| |
| if (! _bClearSalt) |
| { |
| // wilful contamination |
| pSaltData[0] = 1; |
| } |
| |
| rtlDigestError aError = rtl_digest_PBKDF2(pKeyBuffer, nKeyLen, pPassword, nPasswordLen, pSaltData, nSaltDataLen, _nCount); |
| |
| CPPUNIT_ASSERT(aError == rtl_Digest_E_None ); |
| |
| rtl::OString aKey = createHex(pKeyBuffer, nKeyLen); |
| t_print("Key: %s\n", aKey.getStr()); |
| |
| // rtl::OString sSalt = createHex(pSaltData, nSaltDataLen); |
| // t_print("Salt: %s\n", sSalt.getStr()); |
| |
| // CPPUNIT_ASSERT_MESSAGE("md5sum of sample string is wrong. Code changes or sample problems, please check.", aStr.equals(sSampleString_PBKDF2) ); |
| |
| delete [] pSaltData; |
| delete [] pKeyBuffer; |
| return aKey; |
| } |
| |
| void PBKDF2_001() |
| { |
| rtl::OString aPassword = "Password"; |
| |
| // all permutations |
| run_check_PBKDF2(aPassword, false, 1); |
| run_check_PBKDF2(aPassword, false, 2); |
| run_check_PBKDF2(aPassword, true, 1); |
| run_check_PBKDF2(aPassword, true, 2); |
| run_check_PBKDF2(aPassword, false, 3); |
| run_check_PBKDF2(aPassword, false, 4); |
| run_check_PBKDF2(aPassword, true, 3); |
| run_check_PBKDF2(aPassword, true, 4); |
| } |
| // Change the following lines only, if you add, remove or rename |
| // member functions of the current class, |
| // because these macros are need by auto register mechanism. |
| |
| CPPUNIT_TEST_SUITE(digest_PBKDF2); |
| CPPUNIT_TEST( PBKDF2_001 ); |
| CPPUNIT_TEST_SUITE_END(); |
| }; // class create |
| // ----------------------------------------------------------------------------- |
| |
| class update : public CppUnit::TestFixture |
| { |
| public: |
| // initialise your test code values here. |
| void setUp() |
| { |
| } |
| |
| void tearDown() |
| { |
| } |
| |
| void update_000() |
| { |
| rtlDigest aHandle = NULL; |
| rtlDigestError aError = rtl_digest_update(aHandle, NULL, 0); |
| CPPUNIT_ASSERT_MESSAGE("does not handle wrong parameter", aError == rtl_Digest_E_Argument ); |
| } |
| |
| void updateMD2_000() |
| { |
| rtlDigest aHandle = NULL; |
| rtlDigestError aError = rtl_digest_updateMD2(aHandle, NULL, 0); |
| CPPUNIT_ASSERT_MESSAGE("does not handle wrong parameter", aError == rtl_Digest_E_Argument ); |
| } |
| |
| void updateMD2_001() |
| { |
| rtlDigest aHandle = rtl_digest_create( rtl_Digest_AlgorithmMD2 ); |
| CPPUNIT_ASSERT_MESSAGE("create with rtl_Digest_AlgorithmMD2", aHandle != 0); |
| |
| rtl::OString aMsg = sSampleString; |
| const sal_uInt8* pData = (const sal_uInt8*)aMsg.getStr(); |
| |
| rtlDigestError aError = rtl_digest_updateMD2(aHandle, NULL, 0); |
| CPPUNIT_ASSERT_MESSAGE("handle parameter 'pData' wrong", aError == rtl_Digest_E_Argument ); |
| |
| /* rtlDigestError */ aError = rtl_digest_updateMD2(aHandle, pData, 0); |
| CPPUNIT_ASSERT_MESSAGE("handle parameter 'nSize' wrong", aError == rtl_Digest_E_None ); |
| |
| rtl_digest_destroyMD2(aHandle); |
| } |
| void updateMD5_000() |
| { |
| rtlDigest aHandle = NULL; |
| rtlDigestError aError = rtl_digest_updateMD5(aHandle, NULL, 0); |
| CPPUNIT_ASSERT_MESSAGE("does not handle wrong parameter", aError == rtl_Digest_E_Argument ); |
| } |
| |
| void updateMD5_001() |
| { |
| // use wrong Algorithm!!! This is volitional! |
| rtlDigest aHandle = rtl_digest_create( rtl_Digest_AlgorithmMD2 ); |
| CPPUNIT_ASSERT_MESSAGE("create with rtl_Digest_AlgorithmMD2", aHandle != 0); |
| |
| rtl::OString aMsg = sSampleString; |
| const sal_uInt8* pData = (const sal_uInt8*)aMsg.getStr(); |
| sal_uInt32 nSize = ( aMsg.getLength() ); |
| |
| rtlDigestError aError = rtl_digest_updateMD5(aHandle, pData, nSize); |
| CPPUNIT_ASSERT_MESSAGE("handle parameter 'handle' wrong", aError == rtl_Digest_E_Algorithm ); |
| |
| rtl_digest_destroyMD5(aHandle); |
| } |
| |
| void updateMD5_002() |
| { |
| rtlDigest aHandle = rtl_digest_create( rtl_Digest_AlgorithmMD5 ); |
| CPPUNIT_ASSERT_MESSAGE("create with rtl_Digest_AlgorithmMD5", aHandle != 0); |
| |
| rtl::OString aMsg = sSampleString; |
| const sal_uInt8* pData = (const sal_uInt8*)aMsg.getStr(); |
| |
| rtlDigestError aError = rtl_digest_updateMD5(aHandle, NULL, 0); |
| CPPUNIT_ASSERT_MESSAGE("handle parameter 'pData' wrong", aError == rtl_Digest_E_Argument ); |
| |
| /* rtlDigestError */ aError = rtl_digest_updateMD5(aHandle, pData, 0); |
| CPPUNIT_ASSERT_MESSAGE("handle parameter 'nSize' wrong", aError == rtl_Digest_E_None ); |
| |
| rtl_digest_destroyMD5(aHandle); |
| } |
| |
| void updateSHA_000() |
| { |
| rtlDigest aHandle = NULL; |
| rtlDigestError aError = rtl_digest_updateSHA(aHandle, NULL, 0); |
| CPPUNIT_ASSERT_MESSAGE("does not handle wrong parameter", aError == rtl_Digest_E_Argument ); |
| } |
| |
| void updateSHA1_000() |
| { |
| rtlDigest aHandle = NULL; |
| rtlDigestError aError = rtl_digest_updateSHA1(aHandle, NULL, 0); |
| CPPUNIT_ASSERT_MESSAGE("does not handle wrong parameter", aError == rtl_Digest_E_Argument ); |
| } |
| |
| void updateHMAC_MD5_000() |
| { |
| rtlDigest aHandle = NULL; |
| rtlDigestError aError = rtl_digest_updateHMAC_MD5(aHandle, NULL, 0); |
| CPPUNIT_ASSERT_MESSAGE("does not handle wrong parameter", aError == rtl_Digest_E_Argument ); |
| } |
| |
| void updateHMAC_SHA1_000() |
| { |
| rtlDigest aHandle = NULL; |
| rtlDigestError aError = rtl_digest_updateHMAC_SHA1(aHandle, NULL, 0); |
| CPPUNIT_ASSERT_MESSAGE("does not handle wrong parameter", aError == rtl_Digest_E_Argument ); |
| } |
| |
| // Change the following lines only, if you add, remove or rename |
| // member functions of the current class, |
| // because these macros are need by auto register mechanism. |
| |
| CPPUNIT_TEST_SUITE(update); |
| CPPUNIT_TEST(update_000); |
| CPPUNIT_TEST(updateMD5_000); |
| CPPUNIT_TEST(updateMD5_001); |
| CPPUNIT_TEST(updateMD5_002); |
| CPPUNIT_TEST(updateMD5_000); |
| CPPUNIT_TEST(updateSHA_000); |
| CPPUNIT_TEST(updateSHA1_000); |
| CPPUNIT_TEST(updateHMAC_MD5_000); |
| CPPUNIT_TEST(updateHMAC_SHA1_000); |
| CPPUNIT_TEST_SUITE_END(); |
| }; // class create |
| // ----------------------------------------------------------------------------- |
| |
| class get : public CppUnit::TestFixture |
| { |
| public: |
| // initialise your test code values here. |
| void setUp() |
| { |
| } |
| |
| void tearDown() |
| { |
| } |
| |
| void get_000() |
| { |
| rtlDigest aHandle = NULL; |
| rtlDigestError aError = rtl_digest_get(aHandle, NULL, 0); |
| CPPUNIT_ASSERT_MESSAGE("does not handle wrong parameter", aError == rtl_Digest_E_Argument ); |
| } |
| void getMD5_000() |
| { |
| rtlDigest aHandle = NULL; |
| rtlDigestError aError = rtl_digest_getMD5(aHandle, NULL, 0); |
| CPPUNIT_ASSERT_MESSAGE("does not handle wrong parameter", aError == rtl_Digest_E_Argument ); |
| } |
| void getMD5_001() |
| { |
| // test with wrong algorithm |
| rtlDigest aHandle = rtl_digest_create( rtl_Digest_AlgorithmMD2 ); |
| CPPUNIT_ASSERT_MESSAGE("create with rtl_Digest_AlgorithmMD2", aHandle != 0); |
| |
| sal_uInt32 nKeyLen = rtl_digest_queryLength( aHandle ); |
| sal_uInt8 *pKeyBuffer = new sal_uInt8[ nKeyLen ]; |
| |
| rtlDigestError aError = rtl_digest_getMD5(aHandle, NULL, 0); |
| CPPUNIT_ASSERT_MESSAGE("handle 2. parameter wrong", aError == rtl_Digest_E_Argument ); |
| |
| /* rtlDigestError */ aError = rtl_digest_getMD5(aHandle, pKeyBuffer, 0); |
| CPPUNIT_ASSERT_MESSAGE("handle parameter 'handle' wrong", aError == rtl_Digest_E_Algorithm ); |
| |
| rtl_digest_destroyMD2(aHandle); |
| } |
| |
| void getMD5_002() |
| { |
| rtlDigest aHandle = rtl_digest_create( rtl_Digest_AlgorithmMD5 ); |
| CPPUNIT_ASSERT_MESSAGE("create with rtl_Digest_AlgorithmMD5", aHandle != 0); |
| |
| sal_uInt32 nKeyLen = rtl_digest_queryLength( aHandle ); |
| sal_uInt8 *pKeyBuffer = new sal_uInt8[ nKeyLen ]; |
| |
| rtlDigestError aError = rtl_digest_getMD5(aHandle, NULL /* pKeyBuffer */ , nKeyLen); |
| CPPUNIT_ASSERT_MESSAGE("handle parameter 'pData' wrong", aError == rtl_Digest_E_Argument ); |
| |
| /* rtlDigestError */ aError = rtl_digest_getMD5(aHandle, pKeyBuffer, 0); |
| CPPUNIT_ASSERT_MESSAGE("handle parameter 'nSize' wrong", aError == rtl_Digest_E_BufferSize ); |
| |
| rtl_digest_destroyMD5(aHandle); |
| delete [] pKeyBuffer; |
| } |
| |
| // Change the following lines only, if you add, remove or rename |
| // member functions of the current class, |
| // because these macros are need by auto register mechanism. |
| |
| CPPUNIT_TEST_SUITE(get); |
| CPPUNIT_TEST(get_000); |
| CPPUNIT_TEST(getMD5_000); |
| CPPUNIT_TEST(getMD5_001); |
| CPPUNIT_TEST(getMD5_002); |
| CPPUNIT_TEST_SUITE_END(); |
| }; // class create |
| |
| // ----------------------------------------------------------------------------- |
| class destroy : public CppUnit::TestFixture |
| { |
| public: |
| // initialise your test code values here. |
| void setUp() |
| { |
| } |
| |
| void tearDown() |
| { |
| } |
| |
| void destroy_001() |
| { |
| rtlDigest handle = rtl_digest_create( rtl_Digest_AlgorithmMD5 ); |
| CPPUNIT_ASSERT_MESSAGE("create with rtl_Digest_AlgorithmMD5", handle != 0); |
| |
| // not really testable |
| // LLA: good will test. |
| rtl_digest_destroy( handle ); |
| } |
| |
| // Change the following lines only, if you add, remove or rename |
| // member functions of the current class, |
| // because these macros are need by auto register mechanism. |
| |
| CPPUNIT_TEST_SUITE(destroy); |
| CPPUNIT_TEST(destroy_001); |
| CPPUNIT_TEST_SUITE_END(); |
| }; // class create |
| // ----------------------------------------------------------------------------- |
| |
| CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_digest::create, "rtl_digest"); |
| CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_digest::createMD2, "rtl_digest"); |
| CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_digest::createMD5, "rtl_digest"); |
| CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_digest::createSHA, "rtl_digest"); |
| CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_digest::createSHA1, "rtl_digest"); |
| CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_digest::createHMAC_MD5, "rtl_digest"); |
| CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_digest::createHMAC_SHA1, "rtl_digest"); |
| |
| CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_digest::destroy, "rtl_digest"); |
| |
| CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_digest::queryAlgorithm, "rtl_digest"); |
| CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_digest::queryLength, "rtl_digest"); |
| CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_digest::init, "rtl_digest"); |
| CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_digest::equalTests, "rtl_digest"); |
| |
| CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_digest::digest_MD2, "rtl_digest"); |
| CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_digest::digest_MD5, "rtl_digest"); |
| CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_digest::digest_SHA, "rtl_digest"); |
| CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_digest::digest_SHA1, "rtl_digest"); |
| CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_digest::digest_HMAC_MD5, "rtl_digest"); |
| CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_digest::digest_HMAC_SHA1, "rtl_digest"); |
| CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_digest::digest_PBKDF2, "rtl_digest"); |
| |
| CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_digest::update, "rtl_digest"); |
| CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_digest::get, "rtl_digest"); |
| CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_digest::destroy, "rtl_digest"); |
| } // namespace rtl_digest |
| |
| |
| // ----------------------------------------------------------------------------- |
| |
| // this macro creates an empty function, which will called by the RegisterAllFunctions() |
| // to let the user the possibility to also register some functions by hand. |
| NOADDITIONAL; |
