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