sal/qa/rtl/cipher/rtl_cipher.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: rtl_cipher.cxx,v $
  10  * $Revision: 1.4 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31
  32 // MARKER(update_precomp.py): autogen include statement, do not remove
  33 #include "precompiled_sal.hxx"
  34
  35 #include <cppunit/simpleheader.hxx>
  36 #include <rtl/strbuf.hxx>
  37 #include <rtl/cipher.h>
  38
  39 // -----------------------------------------------------------------------------
  40 namespace rtl_cipher
  41 {
  42
  43 rtl::OString createHex(sal_uInt8 *_pKeyBuffer, sal_uInt32 _nKeyLen)
  44 {
  45     // Create hex-value string from the  value to keep the string size minimal
  46     rtl::OStringBuffer aBuffer( _nKeyLen * 2 + 1 );
  47     for ( sal_uInt32 i = 0; i < _nKeyLen; i++ )
  48     {
  49         sal_Int32 nValue = (sal_Int32)_pKeyBuffer[i];
  50         if (nValue < 16)                         // maximul hex value for 1 byte
  51         {
  52             aBuffer.append( sal_Int32(0), 16 /* radix */ );
  53         }
  54         aBuffer.append( nValue, 16 /* radix */ );
  55     }
  56
  57     return aBuffer.makeStringAndClear();
  58 }
  59
  60 // -----------------------------------------------------------------------------
  61
  62 class create : public CppUnit::TestFixture
  63 {
  64 public:
  65     // initialise your test code values here.
  66     void setUp()
  67     {
  68     }
  69
  70     void tearDown()
  71     {
  72     }
  73
  74     void create_001()
  75         {
  76             rtlCipher aCipher = rtl_cipher_create(rtl_Cipher_AlgorithmBF, rtl_Cipher_ModeECB);
  77             CPPUNIT_ASSERT_MESSAGE("create failed.", aCipher != NULL);
  78             rtl_cipher_destroy(aCipher);
  79         }
  80     void create_002()
  81         {
  82             rtlCipher aCipher = rtl_cipher_create(rtl_Cipher_AlgorithmInvalid, rtl_Cipher_ModeECB);
  83             CPPUNIT_ASSERT_MESSAGE("create provide wrong object.", aCipher == NULL);
  84         }
  85     void create_003()
  86         {
  87             rtlCipher aCipher = rtl_cipher_create(rtl_Cipher_AlgorithmBF, rtl_Cipher_ModeCBC);
  88             CPPUNIT_ASSERT_MESSAGE("create failed.", aCipher != NULL);
  89             rtl_cipher_destroy(aCipher);
  90         }
  91     void create_004()
  92         {
  93             rtlCipher aCipher = rtl_cipher_create(rtl_Cipher_AlgorithmInvalid, rtl_Cipher_ModeCBC);
  94             CPPUNIT_ASSERT_MESSAGE("create provide wrong object.", aCipher == NULL);
  95         }
  96     void create_005()
  97         {
  98             rtlCipher aCipher = rtl_cipher_create(rtl_Cipher_AlgorithmBF, rtl_Cipher_ModeStream);
  99             CPPUNIT_ASSERT_MESSAGE("create failed.", aCipher != NULL);
 100             rtl_cipher_destroy(aCipher);
 101         }
 102     void create_006()
 103         {
 104             rtlCipher aCipher = rtl_cipher_create(rtl_Cipher_AlgorithmInvalid, rtl_Cipher_ModeStream);
 105             CPPUNIT_ASSERT_MESSAGE("create provide wrong object.", aCipher == NULL);
 106         }
 107     void create_007()
 108         {
 109             rtlCipher aCipher = rtl_cipher_create(rtl_Cipher_AlgorithmBF, rtl_Cipher_ModeInvalid);
 110             CPPUNIT_ASSERT_MESSAGE("create provide wrong object.", aCipher == NULL);
 111         }
 112     void create_008()
 113         {
 114             rtlCipher aCipher = rtl_cipher_create(rtl_Cipher_AlgorithmInvalid, rtl_Cipher_ModeInvalid);
 115             CPPUNIT_ASSERT_MESSAGE("create provide wrong object.", aCipher == NULL);
 116         }
 117
 118     // Change the following lines only, if you add, remove or rename
 119     // member functions of the current class,
 120     // because these macros are need by auto register mechanism.
 121
 122     CPPUNIT_TEST_SUITE(create);
 123     CPPUNIT_TEST(create_001);
 124     CPPUNIT_TEST(create_002);
 125     CPPUNIT_TEST(create_003);
 126     CPPUNIT_TEST(create_004);
 127     CPPUNIT_TEST(create_005);
 128     CPPUNIT_TEST(create_006);
 129     CPPUNIT_TEST(create_007);
 130     CPPUNIT_TEST(create_008);
 131     CPPUNIT_TEST_SUITE_END();
 132 }; // class create
 133
 134 // -----------------------------------------------------------------------------
 135 class createBF : public CppUnit::TestFixture
 136 {
 137 public:
 138     // initialise your test code values here.
 139     void setUp()
 140     {
 141     }
 142
 143     void tearDown()
 144     {
 145     }
 146
 147     void createBF_001()
 148         {
 149             rtlCipher aCipher = rtl_cipher_createBF(rtl_Cipher_ModeECB);
 150             CPPUNIT_ASSERT_MESSAGE("create failed.", aCipher != NULL);
 151             rtl_cipher_destroy(aCipher);
 152         }
 153     void createBF_002()
 154         {
 155             rtlCipher aCipher = rtl_cipher_createBF(rtl_Cipher_ModeCBC);
 156             CPPUNIT_ASSERT_MESSAGE("create failed.", aCipher != NULL);
 157             rtl_cipher_destroy(aCipher);
 158         }
 159     void createBF_003()
 160         {
 161             rtlCipher aCipher = rtl_cipher_createBF(rtl_Cipher_ModeStream);
 162             CPPUNIT_ASSERT_MESSAGE("create failed.", aCipher != NULL);
 163             rtl_cipher_destroy(aCipher);
 164         }
 165     void createBF_004()
 166         {
 167             rtlCipher aCipher = rtl_cipher_createBF(rtl_Cipher_ModeInvalid);
 168             CPPUNIT_ASSERT_MESSAGE("create provide wrong object.", aCipher == NULL);
 169             // rtl_cipher_destroy(aCipher);
 170         }
 171     // Change the following lines only, if you add, remove or rename
 172     // member functions of the current class,
 173     // because these macros are need by auto register mechanism.
 174
 175     CPPUNIT_TEST_SUITE(createBF);
 176     CPPUNIT_TEST(createBF_001);
 177     CPPUNIT_TEST(createBF_002);
 178     CPPUNIT_TEST(createBF_003);
 179     CPPUNIT_TEST(createBF_004);
 180     CPPUNIT_TEST_SUITE_END();
 181 }; // class createBF
 182 // -----------------------------------------------------------------------------
 183 class decode : public CppUnit::TestFixture
 184 {
 185 public:
 186     // initialise your test code values here.
 187     void setUp()
 188     {
 189     }
 190
 191     void tearDown()
 192     {
 193     }
 194
 195     void test_encode(sal_uInt8 _nKeyValue, sal_uInt8 _nArgValue, rtl::OString const& _sPlainTextStr)
 196         {
 197             rtlCipher aCipher = rtl_cipher_create(rtl_Cipher_AlgorithmBF, rtl_Cipher_ModeECB);
 198             CPPUNIT_ASSERT_MESSAGE("create failed.", aCipher != NULL);
 199
 200             sal_uInt32     nKeyLen = 16;
 201             sal_uInt8     *pKeyBuffer = new sal_uInt8[ nKeyLen ];
 202             memset(pKeyBuffer, 0, nKeyLen);
 203             pKeyBuffer[0] = _nKeyValue;
 204
 205             sal_uInt32     nArgLen = 16;
 206             sal_uInt8     *pArgBuffer = new sal_uInt8[ nArgLen ];
 207             memset(pArgBuffer, 0, nArgLen);
 208             pArgBuffer[0] = _nArgValue;
 209
 210             t_print(T_VERBOSE, "  init Key: %s\n", createHex(pKeyBuffer, nKeyLen).getStr());
 211             t_print(T_VERBOSE, "  init Arg: %s\n", createHex(pArgBuffer, nArgLen).getStr());
 212
 213             rtlCipherError aError = rtl_cipher_init(aCipher, rtl_Cipher_DirectionEncode, pKeyBuffer, nKeyLen, pArgBuffer, nArgLen);
 214             CPPUNIT_ASSERT_MESSAGE("wrong init", aError == rtl_Cipher_E_None);
 215
 216             sal_uInt32     nPlainTextLen = 16;
 217             sal_uInt8     *pPlainTextBuffer = new sal_uInt8[ nPlainTextLen ];
 218             memset(pPlainTextBuffer, 0, nPlainTextLen);
 219             strncpy((char*)pPlainTextBuffer, _sPlainTextStr.getStr(), 16);
 220
 221             sal_uInt32     nCipherLen = 16;
 222             sal_uInt8     *pCipherBuffer = new sal_uInt8[ nCipherLen ];
 223             memset(pCipherBuffer, 0, nCipherLen);
 224
 225             /* rtlCipherError */ aError = rtl_cipher_encode(aCipher, pPlainTextBuffer, nPlainTextLen, pCipherBuffer, nCipherLen);
 226             CPPUNIT_ASSERT_MESSAGE("wrong encode", aError == rtl_Cipher_E_None);
 227
 228             t_print(T_VERBOSE, "       Key: %s\n", createHex(pKeyBuffer, nKeyLen).getStr());
 229             t_print(T_VERBOSE, "       Arg: %s\n", createHex(pArgBuffer, nArgLen).getStr());
 230             t_print(T_VERBOSE, "     Plain: %s\n", createHex(pPlainTextBuffer, nPlainTextLen).getStr());
 231             t_print(           "Cipher Buf: %s\n", createHex(pCipherBuffer, nCipherLen).getStr());
 232
 233             sal_uInt32     nPlainText2Len = 16;
 234             sal_uInt8     *pPlainText2Buffer = new sal_uInt8[ nPlainText2Len ];
 235             memset(pPlainText2Buffer, 0, nPlainText2Len);
 236
 237             /* rtlCipherError */ aError = rtl_cipher_decode(aCipher, pCipherBuffer, nCipherLen, pPlainText2Buffer, nPlainText2Len);
 238             CPPUNIT_ASSERT_MESSAGE("decode should not work", aError != rtl_Cipher_E_None);
 239
 240             // rtl::OString sPlainText2Str((char*)pPlainText2Buffer, nPlainText2Len);
 241             // t_print(T_VERBOSE, " Plain: %s\n", createHex(pPlainText2Buffer, nPlainText2Len).getStr());
 242             // t_print(T_VERBOSE, " ascii: %s\n", sPlainText2Str.getStr());
 243             //
 244             // // t_print("   Buf: %s\n", createHex(pCipherBuffer, nCipherLen).getStr());
 245             //
 246             // sal_Int32 nCompare = memcmp(pPlainTextBuffer, pPlainText2Buffer, 16);
 247             //
 248             // CPPUNIT_ASSERT_MESSAGE("compare between plain and decoded plain failed", nCompare == 0);
 249             //
 250             // delete [] pPlainText2Buffer;
 251             //
 252             // delete [] pCipherBuffer;
 253             // delete [] pPlainTextBuffer;
 254             //
 255             // delete [] pArgBuffer;
 256             // delete [] pKeyBuffer;
 257             //
 258             // rtl_cipher_destroy(aCipher);
 259         }
 260
 261     void test_encode_and_decode(sal_uInt8 _nKeyValue, sal_uInt8 _nArgValue, rtl::OString const& _sPlainTextStr)
 262         {
 263             rtlCipher aCipher = rtl_cipher_create(rtl_Cipher_AlgorithmBF, rtl_Cipher_ModeECB);
 264             CPPUNIT_ASSERT_MESSAGE("create failed.", aCipher != NULL);
 265
 266             sal_uInt32     nKeyLen = 16;
 267             sal_uInt8     *pKeyBuffer = new sal_uInt8[ nKeyLen ];
 268             memset(pKeyBuffer, 0, nKeyLen);
 269             pKeyBuffer[0] = _nKeyValue;
 270
 271             sal_uInt32     nArgLen = 16;
 272             sal_uInt8     *pArgBuffer = new sal_uInt8[ nArgLen ];
 273             memset(pArgBuffer, 0, nArgLen);
 274             pArgBuffer[0] = _nArgValue;
 275
 276             t_print(T_VERBOSE, "  init Key: %s\n", createHex(pKeyBuffer, nKeyLen).getStr());
 277             t_print(T_VERBOSE, "  init Arg: %s\n", createHex(pArgBuffer, nArgLen).getStr());
 278
 279             rtlCipherError aError = rtl_cipher_init(aCipher, rtl_Cipher_DirectionBoth, pKeyBuffer, nKeyLen, pArgBuffer, nArgLen);
 280             CPPUNIT_ASSERT_MESSAGE("wrong init", aError == rtl_Cipher_E_None);
 281
 282             sal_uInt32     nPlainTextLen = 16;
 283             sal_uInt8     *pPlainTextBuffer = new sal_uInt8[ nPlainTextLen ];
 284             memset(pPlainTextBuffer, 0, nPlainTextLen);
 285             strncpy((char*)pPlainTextBuffer, _sPlainTextStr.getStr(), 16);
 286
 287             sal_uInt32     nCipherLen = 16;
 288             sal_uInt8     *pCipherBuffer = new sal_uInt8[ nCipherLen ];
 289             memset(pCipherBuffer, 0, nCipherLen);
 290
 291             /* rtlCipherError */ aError = rtl_cipher_encode(aCipher, pPlainTextBuffer, nPlainTextLen, pCipherBuffer, nCipherLen);
 292             CPPUNIT_ASSERT_MESSAGE("wrong encode", aError == rtl_Cipher_E_None);
 293
 294             t_print(T_VERBOSE, "       Key: %s\n", createHex(pKeyBuffer, nKeyLen).getStr());
 295             t_print(T_VERBOSE, "       Arg: %s\n", createHex(pArgBuffer, nArgLen).getStr());
 296             t_print(T_VERBOSE, "     Plain: %s\n", createHex(pPlainTextBuffer, nPlainTextLen).getStr());
 297             t_print(           "Cipher Buf: %s\n", createHex(pCipherBuffer, nCipherLen).getStr());
 298
 299             sal_uInt32     nPlainText2Len = 16;
 300             sal_uInt8     *pPlainText2Buffer = new sal_uInt8[ nPlainText2Len ];
 301             memset(pPlainText2Buffer, 0, nPlainText2Len);
 302
 303             /* rtlCipherError */ aError = rtl_cipher_decode(aCipher, pCipherBuffer, nCipherLen, pPlainText2Buffer, nPlainText2Len);
 304             CPPUNIT_ASSERT_MESSAGE("wrong decode", aError == rtl_Cipher_E_None);
 305
 306             rtl::OString sPlainText2Str((char*)pPlainText2Buffer, nPlainText2Len);
 307             t_print(T_VERBOSE, "     Plain: %s\n", createHex(pPlainText2Buffer, nPlainText2Len).getStr());
 308             t_print(T_VERBOSE, "  as ascii: %s\n", sPlainText2Str.getStr());
 309
 310             // t_print("   Buf: %s\n", createHex(pCipherBuffer, nCipherLen).getStr());
 311
 312             sal_Int32 nCompare = memcmp(pPlainTextBuffer, pPlainText2Buffer, 16);
 313
 314             CPPUNIT_ASSERT_MESSAGE("compare between plain and decoded plain failed", nCompare == 0);
 315
 316             delete [] pPlainText2Buffer;
 317
 318             delete [] pCipherBuffer;
 319             delete [] pPlainTextBuffer;
 320
 321             delete [] pArgBuffer;
 322             delete [] pKeyBuffer;
 323
 324             rtl_cipher_destroy(aCipher);
 325         }
 326
 327     void decode_001()
 328         {
 329             test_encode_and_decode(0,0,"");
 330             test_encode_and_decode(0,0,"hallo");
 331             test_encode_and_decode(1,0,"B2Aahg5B");
 332             test_encode_and_decode(1,2,"Longer text string");
 333         }
 334
 335     void decode_002()
 336         {
 337             test_encode(0,0,"");
 338             test_encode(0,0,"hallo");
 339             test_encode(1,0,"B2Aahg5B");
 340             test_encode(1,2,"Longer text string");
 341         }
 342     // Change the following lines only, if you add, remove or rename
 343     // member functions of the current class,
 344     // because these macros are need by auto register mechanism.
 345
 346     CPPUNIT_TEST_SUITE(decode);
 347     CPPUNIT_TEST(decode_001);
 348     CPPUNIT_TEST(decode_002);
 349     CPPUNIT_TEST_SUITE_END();
 350 }; // class decode
 351 // -----------------------------------------------------------------------------
 352 class decodeBF : public CppUnit::TestFixture
 353 {
 354 public:
 355     // initialise your test code values here.
 356     void setUp()
 357     {
 358     }
 359
 360     void tearDown()
 361     {
 362     }
 363
 364     void decodeBF_001()
 365         {
 366         }
 367     // Change the following lines only, if you add, remove or rename
 368     // member functions of the current class,
 369     // because these macros are need by auto register mechanism.
 370
 371     CPPUNIT_TEST_SUITE(decodeBF);
 372     CPPUNIT_TEST(decodeBF_001);
 373     CPPUNIT_TEST_SUITE_END();
 374 }; // class decodeBF
 375 // -----------------------------------------------------------------------------
 376 class destroy : public CppUnit::TestFixture
 377 {
 378 public:
 379     // initialise your test code values here.
 380     void setUp()
 381     {
 382     }
 383
 384     void tearDown()
 385     {
 386     }
 387
 388     void destroy_001()
 389         {
 390             rtlCipher aCipher = rtl_cipher_create(rtl_Cipher_AlgorithmBF, rtl_Cipher_ModeCBC);
 391             CPPUNIT_ASSERT_MESSAGE("create failed.", aCipher != NULL);
 392             rtl_cipher_destroy(aCipher);
 393         }
 394     // Change the following lines only, if you add, remove or rename
 395     // member functions of the current class,
 396     // because these macros are need by auto register mechanism.
 397
 398     CPPUNIT_TEST_SUITE(destroy);
 399     CPPUNIT_TEST(destroy_001);
 400     CPPUNIT_TEST_SUITE_END();
 401 }; // class destroy
 402 // -----------------------------------------------------------------------------
 403 class destroyBF : public CppUnit::TestFixture
 404 {
 405 public:
 406     // initialise your test code values here.
 407     void setUp()
 408     {
 409     }
 410
 411     void tearDown()
 412     {
 413     }
 414
 415     void destroyBF_001()
 416         {
 417             rtlCipher aCipher = rtl_cipher_createBF(rtl_Cipher_ModeECB);
 418             CPPUNIT_ASSERT_MESSAGE("create failed.", aCipher != NULL);
 419             rtl_cipher_destroyBF(aCipher);
 420             // more proforma
 421             // should not GPF
 422         }
 423     // Change the following lines only, if you add, remove or rename
 424     // member functions of the current class,
 425     // because these macros are need by auto register mechanism.
 426
 427     CPPUNIT_TEST_SUITE(destroyBF);
 428     CPPUNIT_TEST(destroyBF_001);
 429     CPPUNIT_TEST_SUITE_END();
 430 }; // class destroyBF
 431 // -----------------------------------------------------------------------------
 432 class encode : public CppUnit::TestFixture
 433 {
 434 public:
 435     // initialise your test code values here.
 436     void setUp()
 437     {
 438     }
 439
 440     void tearDown()
 441     {
 442     }
 443
 444     void test_encode(sal_uInt8 _nKeyValue, sal_uInt8 _nArgValue, sal_uInt8 _nDataValue)
 445         {
 446             rtlCipher aCipher = rtl_cipher_create(rtl_Cipher_AlgorithmBF, rtl_Cipher_ModeECB);
 447             CPPUNIT_ASSERT_MESSAGE("create failed.", aCipher != NULL);
 448
 449             sal_uInt32     nKeyLen = 16;
 450             sal_uInt8     *pKeyBuffer = new sal_uInt8[ nKeyLen ];
 451             memset(pKeyBuffer, 0, nKeyLen);
 452             pKeyBuffer[0] = _nKeyValue;
 453
 454             sal_uInt32     nArgLen = 16;
 455             sal_uInt8     *pArgBuffer = new sal_uInt8[ nArgLen ];
 456             memset(pArgBuffer, 0, nArgLen);
 457             pArgBuffer[0] = _nArgValue;
 458
 459             t_print(T_VERBOSE, "init Key: %s\n", createHex(pKeyBuffer, nKeyLen).getStr());
 460             t_print(T_VERBOSE, "init Arg: %s\n", createHex(pArgBuffer, nArgLen).getStr());
 461
 462             rtlCipherError aError = rtl_cipher_init(aCipher, rtl_Cipher_DirectionEncode, pKeyBuffer, nKeyLen, pArgBuffer, nArgLen);
 463             CPPUNIT_ASSERT_MESSAGE("wrong init", aError == rtl_Cipher_E_None);
 464
 465             sal_uInt32     nDataLen = 16;
 466             sal_uInt8     *pDataBuffer = new sal_uInt8[ nDataLen ];
 467             memset(pDataBuffer, 0, nDataLen);
 468             pDataBuffer[0] = _nDataValue;
 469
 470             sal_uInt32     nLen = 16;
 471             sal_uInt8     *pBuffer = new sal_uInt8[ nLen ];
 472             memset(pBuffer, 0, nLen);
 473
 474             /* rtlCipherError */ aError = rtl_cipher_encode(aCipher, pDataBuffer, nDataLen, pBuffer, nLen);
 475             CPPUNIT_ASSERT_MESSAGE("wrong encode", aError == rtl_Cipher_E_None);
 476
 477             t_print(T_VERBOSE, " Key: %s\n", createHex(pKeyBuffer, nKeyLen).getStr());
 478             t_print(T_VERBOSE, " Arg: %s\n", createHex(pArgBuffer, nArgLen).getStr());
 479             t_print(T_VERBOSE, "Data: %s\n", createHex(pDataBuffer, nDataLen).getStr());
 480             t_print(T_VERBOSE, " Buf: %s\n", createHex(pBuffer, nLen).getStr());
 481
 482             delete [] pBuffer;
 483             delete [] pDataBuffer;
 484
 485             delete [] pArgBuffer;
 486             delete [] pKeyBuffer;
 487
 488             rtl_cipher_destroy(aCipher);
 489         }
 490
 491     void encode_001()
 492         {
 493             test_encode(0,0,0);
 494             test_encode(1,0,0);
 495             test_encode(0,1,0);
 496             test_encode(1,1,0);
 497
 498             test_encode(0,0,1);
 499             test_encode(1,0,1);
 500             test_encode(0,1,1);
 501             test_encode(1,1,1);
 502         }
 503
 504     // Change the following lines only, if you add, remove or rename
 505     // member functions of the current class,
 506     // because these macros are need by auto register mechanism.
 507
 508     CPPUNIT_TEST_SUITE(encode);
 509     CPPUNIT_TEST(encode_001);
 510     CPPUNIT_TEST_SUITE_END();
 511 }; // class encode
 512 // -----------------------------------------------------------------------------
 513 class encodeBF : public CppUnit::TestFixture
 514 {
 515 public:
 516     // initialise your test code values here.
 517     void setUp()
 518     {
 519     }
 520
 521     void tearDown()
 522     {
 523     }
 524
 525     void encodeBF_001()
 526         {
 527         }
 528     // Change the following lines only, if you add, remove or rename
 529     // member functions of the current class,
 530     // because these macros are need by auto register mechanism.
 531
 532     CPPUNIT_TEST_SUITE(encodeBF);
 533     CPPUNIT_TEST(encodeBF_001);
 534     CPPUNIT_TEST_SUITE_END();
 535 }; // class encodeBF
 536 // -----------------------------------------------------------------------------
 537 class init : public CppUnit::TestFixture
 538 {
 539 public:
 540     // initialise your test code values here.
 541     void setUp()
 542     {
 543     }
 544
 545     void tearDown()
 546     {
 547     }
 548
 549     void init_001()
 550         {
 551             rtlCipher aCipher = rtl_cipher_create(rtl_Cipher_AlgorithmBF, rtl_Cipher_ModeECB);
 552             CPPUNIT_ASSERT_MESSAGE("create failed.", aCipher != NULL);
 553
 554             sal_uInt32     nKeyLen = 16;
 555             sal_uInt8     *pKeyBuffer = new sal_uInt8[ nKeyLen ];
 556             memset(pKeyBuffer, 0, nKeyLen);
 557
 558             sal_uInt32     nArgLen = 16;
 559             sal_uInt8     *pArgBuffer = new sal_uInt8[ nArgLen ];
 560             memset(pArgBuffer, 0, nArgLen);
 561
 562             t_print(T_VERBOSE, "Key: %s\n", createHex(pKeyBuffer, nKeyLen).getStr());
 563             t_print(T_VERBOSE, "Arg: %s\n", createHex(pArgBuffer, nArgLen).getStr());
 564
 565             rtlCipherError aError = rtl_cipher_init(aCipher, rtl_Cipher_DirectionEncode, pKeyBuffer, nKeyLen, pArgBuffer, nArgLen);
 566             CPPUNIT_ASSERT_MESSAGE("wrong init", aError == rtl_Cipher_E_None);
 567
 568             t_print(T_VERBOSE, "Key: %s\n", createHex(pKeyBuffer, nKeyLen).getStr());
 569             t_print(T_VERBOSE, "Arg: %s\n", createHex(pArgBuffer, nArgLen).getStr());
 570
 571             delete [] pArgBuffer;
 572             delete [] pKeyBuffer;
 573
 574             rtl_cipher_destroy(aCipher);
 575         }
 576
 577     void init_002()
 578         {
 579             rtlCipher aCipher = rtl_cipher_create(rtl_Cipher_AlgorithmBF, rtl_Cipher_ModeECB);
 580             CPPUNIT_ASSERT_MESSAGE("create failed.", aCipher != NULL);
 581
 582             sal_uInt32     nKeyLen = 16;
 583             sal_uInt8     *pKeyBuffer = new sal_uInt8[ nKeyLen ];
 584             memset(pKeyBuffer, 0, nKeyLen);
 585             pKeyBuffer[0] = 1;
 586
 587             sal_uInt32     nArgLen = 16;
 588             sal_uInt8     *pArgBuffer = new sal_uInt8[ nArgLen ];
 589             memset(pArgBuffer, 0, nArgLen);
 590
 591             t_print(T_VERBOSE, "Key: %s\n", createHex(pKeyBuffer, nKeyLen).getStr());
 592             t_print(T_VERBOSE, "Arg: %s\n", createHex(pArgBuffer, nArgLen).getStr());
 593
 594             rtlCipherError aError = rtl_cipher_init(aCipher, rtl_Cipher_DirectionEncode, pKeyBuffer, nKeyLen, pArgBuffer, nArgLen);
 595             CPPUNIT_ASSERT_MESSAGE("wrong init", aError == rtl_Cipher_E_None);
 596
 597             t_print(T_VERBOSE, "Key: %s\n", createHex(pKeyBuffer, nKeyLen).getStr());
 598             t_print(T_VERBOSE, "Arg: %s\n", createHex(pArgBuffer, nArgLen).getStr());
 599
 600             delete [] pArgBuffer;
 601             delete [] pKeyBuffer;
 602
 603             rtl_cipher_destroy(aCipher);
 604         }
 605     void init_003()
 606         {
 607             rtlCipher aCipher = rtl_cipher_create(rtl_Cipher_AlgorithmBF, rtl_Cipher_ModeECB);
 608             CPPUNIT_ASSERT_MESSAGE("create failed.", aCipher != NULL);
 609
 610             sal_uInt32     nKeyLen = 16;
 611             sal_uInt8     *pKeyBuffer = new sal_uInt8[ nKeyLen ];
 612             memset(pKeyBuffer, 0, nKeyLen);
 613
 614             sal_uInt32     nArgLen = 16;
 615             sal_uInt8     *pArgBuffer = new sal_uInt8[ nArgLen ];
 616             memset(pArgBuffer, 0, nArgLen);
 617             pArgBuffer[0] = 1;
 618
 619             t_print(T_VERBOSE, "Key: %s\n", createHex(pKeyBuffer, nKeyLen).getStr());
 620             t_print(T_VERBOSE, "Arg: %s\n", createHex(pArgBuffer, nArgLen).getStr());
 621
 622             rtlCipherError aError = rtl_cipher_init(aCipher, rtl_Cipher_DirectionEncode, pKeyBuffer, nKeyLen, pArgBuffer, nArgLen);
 623             CPPUNIT_ASSERT_MESSAGE("wrong init", aError == rtl_Cipher_E_None);
 624
 625             t_print(T_VERBOSE, "Key: %s\n", createHex(pKeyBuffer, nKeyLen).getStr());
 626             t_print(T_VERBOSE, "Arg: %s\n", createHex(pArgBuffer, nArgLen).getStr());
 627
 628             delete [] pArgBuffer;
 629             delete [] pKeyBuffer;
 630
 631             rtl_cipher_destroy(aCipher);
 632         }
 633     void init_004()
 634         {
 635             rtlCipher aCipher = rtl_cipher_create(rtl_Cipher_AlgorithmBF, rtl_Cipher_ModeECB);
 636             CPPUNIT_ASSERT_MESSAGE("create failed.", aCipher != NULL);
 637
 638             sal_uInt32     nKeyLen = 16;
 639             sal_uInt8     *pKeyBuffer = new sal_uInt8[ nKeyLen ];
 640             memset(pKeyBuffer, 0, nKeyLen);
 641             pKeyBuffer[0] = 1;
 642
 643             sal_uInt32     nArgLen = 16;
 644             sal_uInt8     *pArgBuffer = new sal_uInt8[ nArgLen ];
 645             memset(pArgBuffer, 0, nArgLen);
 646             pArgBuffer[0] = 1;
 647
 648             t_print(T_VERBOSE, "Key: %s\n", createHex(pKeyBuffer, nKeyLen).getStr());
 649             t_print(T_VERBOSE, "Arg: %s\n", createHex(pArgBuffer, nArgLen).getStr());
 650
 651             rtlCipherError aError = rtl_cipher_init(aCipher, rtl_Cipher_DirectionEncode, pKeyBuffer, nKeyLen, pArgBuffer, nArgLen);
 652             CPPUNIT_ASSERT_MESSAGE("wrong init", aError == rtl_Cipher_E_None);
 653
 654             t_print(T_VERBOSE, "Key: %s\n", createHex(pKeyBuffer, nKeyLen).getStr());
 655             t_print(T_VERBOSE, "Arg: %s\n", createHex(pArgBuffer, nArgLen).getStr());
 656
 657             delete [] pArgBuffer;
 658             delete [] pKeyBuffer;
 659
 660             rtl_cipher_destroy(aCipher);
 661         }
 662     // Change the following lines only, if you add, remove or rename
 663     // member functions of the current class,
 664     // because these macros are need by auto register mechanism.
 665
 666     CPPUNIT_TEST_SUITE(init);
 667     CPPUNIT_TEST(init_001);
 668     CPPUNIT_TEST(init_002);
 669     CPPUNIT_TEST(init_003);
 670     CPPUNIT_TEST(init_004);
 671     CPPUNIT_TEST_SUITE_END();
 672 }; // class init
 673 // -----------------------------------------------------------------------------
 674 class initBF : public CppUnit::TestFixture
 675 {
 676 public:
 677     // initialise your test code values here.
 678     void setUp()
 679     {
 680     }
 681
 682     void tearDown()
 683     {
 684     }
 685
 686     void initBF_001()
 687         {
 688             // seems to be the same as init, so empty
 689         }
 690
 691     // Change the following lines only, if you add, remove or rename
 692     // member functions of the current class,
 693     // because these macros are need by auto register mechanism.
 694
 695     CPPUNIT_TEST_SUITE(initBF);
 696     CPPUNIT_TEST(initBF_001);
 697     CPPUNIT_TEST_SUITE_END();
 698 }; // class initBF
 699
 700 // -----------------------------------------------------------------------------
 701
 702 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_cipher::create, "rtl_cipher");
 703 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_cipher::createBF, "rtl_cipher");
 704 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_cipher::decode, "rtl_cipher");
 705 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_cipher::decodeBF, "rtl_cipher");
 706 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_cipher::destroy, "rtl_cipher");
 707 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_cipher::destroyBF, "rtl_cipher");
 708 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_cipher::encode, "rtl_cipher");
 709 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_cipher::encodeBF, "rtl_cipher");
 710 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_cipher::init, "rtl_cipher");
 711 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_cipher::initBF, "rtl_cipher");
 712
 713 } // namespace rtl_cipher
 714
 715
 716 // -----------------------------------------------------------------------------
 717
 718 // this macro creates an empty function, which will called by the RegisterAllFunctions()
 719 // to let the user the possibility to also register some functions by hand.
 720 NOADDITIONAL;