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 #include <testshl/simpleheader.hxx> 28 29 #include <rtl/digest.h> 30 #include <rtl/ustring.hxx> 31 #include <rtl/ustrbuf.hxx> 32 #include <rtl/strbuf.hxx> 33 34 // sample, how to use digest 35 36 rtl::OUString CreateMD5FromString( const rtl::OUString& aMsg ) 37 { 38 // PRE: aStr "file" 39 // BACK: Str "ababab....0f" Hexcode String 40 41 rtlDigest handle = rtl_digest_create( rtl_Digest_AlgorithmMD5 ); 42 if ( handle > 0 ) 43 { 44 const sal_uInt8* pData = (const sal_uInt8*)aMsg.getStr(); 45 sal_uInt32 nSize = ( aMsg.getLength() * sizeof( sal_Unicode )); 46 sal_uInt32 nMD5KeyLen = rtl_digest_queryLength( handle ); 47 sal_uInt8* pMD5KeyBuffer = new sal_uInt8[ nMD5KeyLen ]; 48 49 rtl_digest_init( handle, pData, nSize ); 50 rtl_digest_update( handle, pData, nSize ); 51 rtl_digest_get( handle, pMD5KeyBuffer, nMD5KeyLen ); 52 rtl_digest_destroy( handle ); 53 54 // Create hex-value string from the MD5 value to keep the string size minimal 55 rtl::OUStringBuffer aBuffer( nMD5KeyLen * 2 + 1 ); 56 for ( sal_uInt32 i = 0; i < nMD5KeyLen; i++ ) 57 aBuffer.append( (sal_Int32)pMD5KeyBuffer[i], 16 ); 58 59 delete [] pMD5KeyBuffer; 60 return aBuffer.makeStringAndClear(); 61 } 62 63 return rtl::OUString(); 64 } 65 66 // ----------------------------------------------------------------------------- 67 namespace rtl_digest 68 { 69 70 rtl::OString sSampleString = "This is a sample sentence, which we use to check some crypto functions in sal."; 71 rtl::OString sSampleString_MD2 = "647ee6c9d4aa5fdd374ed9d7a156acbf"; 72 rtl::OString sSampleString_MD5 = "b16b903e6fc0b62ae389013ed93fe531"; 73 rtl::OString sSampleString_SHA = "eab2814429b2613301c8a077b806af3680548914"; 74 rtl::OString sSampleString_SHA1 = "2bc5bdb7506a2cdc2fd27fc8b9889343012d5008"; 75 rtl::OString sSampleString_HMAC_MD5 = "dd9cba48c972fba0a882baa72b079674"; 76 rtl::OString sSampleString_HMAC_SHA1 = "5d7f43ce6abd1de4438d7e69e01495864490cf3e"; 77 78 rtl::OString sSampleString_only_one_diff = "This is a sample sentence. which we use to check some crypto functions in sal."; 79 80 class create : public CppUnit::TestFixture 81 { 82 public: 83 // initialise your test code values here. 84 void setUp() 85 { 86 } 87 88 void tearDown() 89 { 90 } 91 92 void create_001() 93 { 94 rtlDigest handle = rtl_digest_create( rtl_Digest_AlgorithmMD5 ); 95 CPPUNIT_ASSERT_MESSAGE("create with rtl_Digest_AlgorithmMD5", handle != 0); 96 rtl_digest_destroy( handle ); 97 } 98 void create_002() 99 { 100 rtlDigest handle = rtl_digest_create( rtl_Digest_AlgorithmMD2 ); 101 CPPUNIT_ASSERT_MESSAGE("create with rtl_Digest_AlgorithmMD2", handle != 0); 102 rtl_digest_destroy( handle ); 103 } 104 void create_003() 105 { 106 rtlDigest handle = rtl_digest_create( rtl_Digest_AlgorithmSHA ); 107 CPPUNIT_ASSERT_MESSAGE("create with rtl_Digest_AlgorithmSHA", handle != 0); 108 rtl_digest_destroy( handle ); 109 } 110 void create_004() 111 { 112 rtlDigest handle = rtl_digest_create( rtl_Digest_AlgorithmSHA1 ); 113 CPPUNIT_ASSERT_MESSAGE("create with rtl_Digest_AlgorithmSHA1", handle != 0); 114 rtl_digest_destroy( handle ); 115 } 116 void create_005() 117 { 118 rtlDigest handle = rtl_digest_create( rtl_Digest_AlgorithmHMAC_MD5 ); 119 CPPUNIT_ASSERT_MESSAGE("create with rtl_Digest_AlgorithmHMAC_MD5", handle != 0); 120 rtl_digest_destroy( handle ); 121 } 122 void create_006() 123 { 124 rtlDigest handle = rtl_digest_create( rtl_Digest_AlgorithmHMAC_SHA1 ); 125 CPPUNIT_ASSERT_MESSAGE("create with rtl_Digest_AlgorithmHMAC_SHA1", handle != 0); 126 rtl_digest_destroy( handle ); 127 } 128 129 void create_007() 130 { 131 rtlDigest handle = rtl_digest_create( rtl_Digest_AlgorithmInvalid ); 132 t_print("Handle is %x\n", handle); 133 CPPUNIT_ASSERT_MESSAGE("create with NULL", handle == 0); 134 rtl_digest_destroy( handle ); 135 } 136 137 // Change the following lines only, if you add, remove or rename 138 // member functions of the current class, 139 // because these macros are need by auto register mechanism. 140 141 CPPUNIT_TEST_SUITE(create); 142 CPPUNIT_TEST(create_001); 143 CPPUNIT_TEST(create_002); 144 CPPUNIT_TEST(create_003); 145 CPPUNIT_TEST(create_004); 146 CPPUNIT_TEST(create_005); 147 CPPUNIT_TEST(create_006); 148 CPPUNIT_TEST(create_007); 149 CPPUNIT_TEST_SUITE_END(); 150 }; // class create 151 152 153 154 155 // ----------------------------------------------------------------------------- 156 157 class createMD5 : public CppUnit::TestFixture 158 { 159 public: 160 // initialise your test code values here. 161 void setUp() 162 { 163 } 164 165 void tearDown() 166 { 167 } 168 169 void createMD5_001() 170 { 171 rtlDigest handle = rtl_digest_createMD5(); 172 173 rtlDigestAlgorithm aAlgo = rtl_digest_queryAlgorithm(handle); 174 CPPUNIT_ASSERT_MESSAGE("query handle", rtl_Digest_AlgorithmMD5 == aAlgo); 175 176 rtl_digest_destroy( handle ); 177 } 178 CPPUNIT_TEST_SUITE(createMD5); 179 CPPUNIT_TEST(createMD5_001); 180 CPPUNIT_TEST_SUITE_END(); 181 }; // class create 182 183 184 // ----------------------------------------------------------------------------- 185 186 class createMD2 : public CppUnit::TestFixture 187 { 188 public: 189 // initialise your test code values here. 190 void setUp() 191 { 192 } 193 194 void tearDown() 195 { 196 } 197 198 void createMD2_001() 199 { 200 rtlDigest handle = rtl_digest_createMD2( ); 201 202 rtlDigestAlgorithm aAlgo = rtl_digest_queryAlgorithm(handle); 203 CPPUNIT_ASSERT_MESSAGE("query handle", rtl_Digest_AlgorithmMD2 == aAlgo); 204 205 rtl_digest_destroy( handle ); 206 } 207 CPPUNIT_TEST_SUITE(createMD2); 208 CPPUNIT_TEST(createMD2_001); 209 CPPUNIT_TEST_SUITE_END(); 210 }; // class create 211 212 // ----------------------------------------------------------------------------- 213 214 class createSHA : public CppUnit::TestFixture 215 { 216 public: 217 // initialise your test code values here. 218 void setUp() 219 { 220 } 221 222 void tearDown() 223 { 224 } 225 226 void createSHA_001() 227 { 228 rtlDigest handle = rtl_digest_createSHA( ); 229 230 rtlDigestAlgorithm aAlgo = rtl_digest_queryAlgorithm(handle); 231 CPPUNIT_ASSERT_MESSAGE("query handle", rtl_Digest_AlgorithmSHA == aAlgo); 232 233 rtl_digest_destroy( handle ); 234 } 235 CPPUNIT_TEST_SUITE(createSHA); 236 CPPUNIT_TEST(createSHA_001); 237 CPPUNIT_TEST_SUITE_END(); 238 }; // class create 239 // ----------------------------------------------------------------------------- 240 241 class createSHA1 : public CppUnit::TestFixture 242 { 243 public: 244 // initialise your test code values here. 245 void setUp() 246 { 247 } 248 249 void tearDown() 250 { 251 } 252 253 void createSHA1_001() 254 { 255 rtlDigest handle = rtl_digest_createSHA1(); 256 257 rtlDigestAlgorithm aAlgo = rtl_digest_queryAlgorithm(handle); 258 CPPUNIT_ASSERT_MESSAGE("query handle", rtl_Digest_AlgorithmSHA1 == aAlgo); 259 260 rtl_digest_destroy( handle ); 261 } 262 CPPUNIT_TEST_SUITE(createSHA1); 263 CPPUNIT_TEST(createSHA1_001); 264 CPPUNIT_TEST_SUITE_END(); 265 }; // class create 266 // ----------------------------------------------------------------------------- 267 268 class createHMAC_MD5 : public CppUnit::TestFixture 269 { 270 public: 271 // initialise your test code values here. 272 void setUp() 273 { 274 } 275 276 void tearDown() 277 { 278 } 279 280 void createHMAC_MD5_001() 281 { 282 rtlDigest handle = rtl_digest_createHMAC_MD5(); 283 284 rtlDigestAlgorithm aAlgo = rtl_digest_queryAlgorithm(handle); 285 CPPUNIT_ASSERT_MESSAGE("query handle", rtl_Digest_AlgorithmHMAC_MD5 == aAlgo); 286 287 rtl_digest_destroy( handle ); 288 } 289 CPPUNIT_TEST_SUITE(createHMAC_MD5); 290 CPPUNIT_TEST(createHMAC_MD5_001); 291 CPPUNIT_TEST_SUITE_END(); 292 }; // class create 293 // ----------------------------------------------------------------------------- 294 295 class createHMAC_SHA1 : public CppUnit::TestFixture 296 { 297 public: 298 // initialise your test code values here. 299 void setUp() 300 { 301 } 302 303 void tearDown() 304 { 305 } 306 307 void createHMAC_SHA1_001() 308 { 309 rtlDigest handle = rtl_digest_createHMAC_SHA1(); 310 311 rtlDigestAlgorithm aAlgo = rtl_digest_queryAlgorithm(handle); 312 CPPUNIT_ASSERT_MESSAGE("query handle", rtl_Digest_AlgorithmHMAC_SHA1 == aAlgo); 313 314 rtl_digest_destroy( handle ); 315 } 316 317 318 CPPUNIT_TEST_SUITE(createHMAC_SHA1); 319 CPPUNIT_TEST(createHMAC_SHA1_001); 320 CPPUNIT_TEST_SUITE_END(); 321 }; // class create 322 323 // ----------------------------------------------------------------------------- 324 325 class queryAlgorithm : public CppUnit::TestFixture 326 { 327 public: 328 // initialise your test code values here. 329 void setUp() 330 { 331 } 332 333 void tearDown() 334 { 335 } 336 337 void query_001() 338 { 339 rtlDigest handle = rtl_digest_create( rtl_Digest_AlgorithmMD5 ); 340 341 rtlDigestAlgorithm aAlgo = rtl_digest_queryAlgorithm(handle); 342 CPPUNIT_ASSERT_MESSAGE("query handle", rtl_Digest_AlgorithmMD5 == aAlgo); 343 344 rtl_digest_destroy( handle ); 345 } 346 void query_002() 347 { 348 rtlDigest handle = rtl_digest_create( rtl_Digest_AlgorithmMD2 ); 349 350 rtlDigestAlgorithm aAlgo = rtl_digest_queryAlgorithm(handle); 351 CPPUNIT_ASSERT_MESSAGE("query handle", rtl_Digest_AlgorithmMD2 == aAlgo); 352 353 rtl_digest_destroy( handle ); 354 } 355 void query_003() 356 { 357 rtlDigest handle = rtl_digest_create( rtl_Digest_AlgorithmSHA ); 358 359 rtlDigestAlgorithm aAlgo = rtl_digest_queryAlgorithm(handle); 360 CPPUNIT_ASSERT_MESSAGE("query handle", rtl_Digest_AlgorithmSHA == aAlgo); 361 362 rtl_digest_destroy( handle ); 363 } 364 void query_004() 365 { 366 rtlDigest handle = rtl_digest_create( rtl_Digest_AlgorithmSHA1 ); 367 368 rtlDigestAlgorithm aAlgo = rtl_digest_queryAlgorithm(handle); 369 CPPUNIT_ASSERT_MESSAGE("query handle", rtl_Digest_AlgorithmSHA1 == aAlgo); 370 371 rtl_digest_destroy( handle ); 372 } 373 void query_005() 374 { 375 rtlDigest handle = rtl_digest_create( rtl_Digest_AlgorithmHMAC_MD5 ); 376 377 rtlDigestAlgorithm aAlgo = rtl_digest_queryAlgorithm(handle); 378 CPPUNIT_ASSERT_MESSAGE("query handle", rtl_Digest_AlgorithmHMAC_MD5 == aAlgo); 379 380 rtl_digest_destroy( handle ); 381 } 382 void query_006() 383 { 384 rtlDigest handle = rtl_digest_create( rtl_Digest_AlgorithmHMAC_SHA1 ); 385 386 rtlDigestAlgorithm aAlgo = rtl_digest_queryAlgorithm(handle); 387 CPPUNIT_ASSERT_MESSAGE("query handle", rtl_Digest_AlgorithmHMAC_SHA1 == aAlgo); 388 389 rtl_digest_destroy( handle ); 390 } 391 void query_007() 392 { 393 rtlDigest handle = rtl_digest_create( rtl_Digest_AlgorithmInvalid ); 394 395 rtlDigestAlgorithm aAlgo = rtl_digest_queryAlgorithm(handle); 396 CPPUNIT_ASSERT_MESSAGE("query handle", rtl_Digest_AlgorithmInvalid == aAlgo); 397 398 rtl_digest_destroy( handle ); 399 } 400 401 // Change the following lines only, if you add, remove or rename 402 // member functions of the current class, 403 // because these macros are need by auto register mechanism. 404 405 CPPUNIT_TEST_SUITE(queryAlgorithm); 406 CPPUNIT_TEST( query_001 ); 407 CPPUNIT_TEST( query_002 ); 408 CPPUNIT_TEST( query_003 ); 409 CPPUNIT_TEST( query_004 ); 410 CPPUNIT_TEST( query_005 ); 411 CPPUNIT_TEST( query_006 ); 412 CPPUNIT_TEST( query_007 ); 413 CPPUNIT_TEST_SUITE_END(); 414 }; // class create 415 416 417 // ----------------------------------------------------------------------------- 418 class queryLength : public CppUnit::TestFixture 419 { 420 public: 421 // initialise your test code values here. 422 void setUp() 423 { 424 } 425 426 void tearDown() 427 { 428 } 429 430 void queryLength_MD5() 431 { 432 rtlDigest handle = rtl_digest_create( rtl_Digest_AlgorithmMD5 ); 433 434 sal_uInt32 nAlgoLength = rtl_digest_queryLength(handle); 435 // t_print("nAlgoLength:=%d\n", nAlgoLength); 436 CPPUNIT_ASSERT_MESSAGE("query Length", RTL_DIGEST_LENGTH_MD5 == nAlgoLength); 437 438 rtl_digest_destroy( handle ); 439 } 440 void queryLength_MD2() 441 { 442 rtlDigest handle = rtl_digest_create( rtl_Digest_AlgorithmMD2 ); 443 444 sal_uInt32 nAlgoLength = rtl_digest_queryLength(handle); 445 // t_print("nAlgoLength:=%d\n", nAlgoLength); 446 CPPUNIT_ASSERT_MESSAGE("query length", RTL_DIGEST_LENGTH_MD2 == nAlgoLength); 447 448 rtl_digest_destroy( handle ); 449 } 450 void queryLength_SHA() 451 { 452 rtlDigest handle = rtl_digest_create( rtl_Digest_AlgorithmSHA ); 453 454 sal_uInt32 nAlgoLength = rtl_digest_queryLength(handle); 455 // t_print("nAlgoLength:=%d\n", nAlgoLength); 456 CPPUNIT_ASSERT_MESSAGE("query length", RTL_DIGEST_LENGTH_SHA == nAlgoLength); 457 458 rtl_digest_destroy( handle ); 459 } 460 void queryLength_SHA1() 461 { 462 rtlDigest handle = rtl_digest_create( rtl_Digest_AlgorithmSHA1 ); 463 464 sal_uInt32 nAlgoLength = rtl_digest_queryLength(handle); 465 // t_print("nAlgoLength:=%d\n", nAlgoLength); 466 CPPUNIT_ASSERT_MESSAGE("query length", RTL_DIGEST_LENGTH_SHA1 == nAlgoLength); 467 468 rtl_digest_destroy( handle ); 469 } 470 void queryLength_HMAC_MD5() 471 { 472 rtlDigest handle = rtl_digest_create( rtl_Digest_AlgorithmHMAC_MD5 ); 473 474 sal_uInt32 nAlgoLength = rtl_digest_queryLength(handle); 475 // t_print("nAlgoLength:=%d\n", nAlgoLength); 476 CPPUNIT_ASSERT_MESSAGE("query length", RTL_DIGEST_LENGTH_HMAC_MD5 == nAlgoLength); 477 478 rtl_digest_destroy( handle ); 479 } 480 void queryLength_HMAC_SHA1() 481 { 482 rtlDigest handle = rtl_digest_create( rtl_Digest_AlgorithmHMAC_SHA1 ); 483 484 sal_uInt32 nAlgoLength = rtl_digest_queryLength(handle); 485 // t_print("nAlgoLength:=%d\n", nAlgoLength); 486 CPPUNIT_ASSERT_MESSAGE("query length", RTL_DIGEST_LENGTH_HMAC_SHA1 == nAlgoLength); 487 488 rtl_digest_destroy( handle ); 489 } 490 491 void queryLength_Illegal() 492 { 493 rtlDigest handle = rtl_digest_create( rtl_Digest_AlgorithmInvalid ); 494 495 sal_uInt32 nAlgoLength = rtl_digest_queryLength(handle); 496 // t_print("nAlgoLength:=%d\n", nAlgoLength); 497 CPPUNIT_ASSERT_MESSAGE("query length", 0 == nAlgoLength); 498 499 rtl_digest_destroy( handle ); 500 } 501 502 // Change the following lines only, if you add, remove or rename 503 // member functions of the current class, 504 // because these macros are need by auto register mechanism. 505 506 CPPUNIT_TEST_SUITE(queryLength); 507 CPPUNIT_TEST( queryLength_MD2 ); 508 CPPUNIT_TEST( queryLength_MD5 ); 509 CPPUNIT_TEST( queryLength_SHA ); 510 CPPUNIT_TEST( queryLength_SHA1 ); 511 CPPUNIT_TEST( queryLength_HMAC_MD5 ); 512 CPPUNIT_TEST( queryLength_HMAC_SHA1 ); 513 CPPUNIT_TEST( queryLength_Illegal ); 514 CPPUNIT_TEST_SUITE_END(); 515 }; // class create 516 517 // ----------------------------------------------------------------------------- 518 519 rtl::OString createHex(sal_uInt8 *_pMD5KeyBuffer, sal_uInt32 _nMD5KeyLen) 520 { 521 // Create hex-value string from the MD5 value to keep the string size minimal 522 rtl::OStringBuffer aBuffer( _nMD5KeyLen * 2 + 1 ); 523 for ( sal_uInt32 i = 0; i < _nMD5KeyLen; i++ ) 524 { 525 sal_Int32 nValue = (sal_Int32)_pMD5KeyBuffer[i]; 526 if (nValue < 16) // maximul hex value for 1 byte 527 { 528 aBuffer.append( sal_Int32(0), 16 /* radix */ ); 529 } 530 aBuffer.append( nValue, 16 /* radix */ ); 531 } 532 533 return aBuffer.makeStringAndClear(); 534 } 535 536 537 // ----------------------------------------------------------------------------- 538 class init : public CppUnit::TestFixture 539 { 540 public: 541 // initialise your test code values here. 542 void setUp() 543 { 544 } 545 546 void tearDown() 547 { 548 } 549 550 void init_000() 551 { 552 rtlDigest handle = NULL; 553 554 rtlDigestError aError = rtl_digest_init(handle, NULL, 0); 555 556 CPPUNIT_ASSERT_MESSAGE("init(NULL, 0, 0)", aError == rtl_Digest_E_Argument); 557 } 558 559 void init_001() 560 { 561 rtlDigest handle = rtl_digest_create( rtl_Digest_AlgorithmMD5 ); 562 563 rtlDigestError aError = rtl_digest_init(handle, NULL, 0); 564 565 CPPUNIT_ASSERT_MESSAGE("init(handle, 0, 0)", aError == rtl_Digest_E_None); 566 567 rtl_digest_destroy( handle ); 568 } 569 570 // ------------------------------------ 571 void init_MD2() 572 { 573 rtlDigest handle = rtl_digest_create( rtl_Digest_AlgorithmMD2 ); 574 575 rtl::OString aMsg = sSampleString; 576 const sal_uInt8 *pData = (const sal_uInt8*)aMsg.getStr(); 577 sal_uInt32 nSize = ( aMsg.getLength() ); 578 579 rtlDigestError aError = rtl_digest_init(handle, pData, nSize); 580 581 CPPUNIT_ASSERT_MESSAGE("init(handle, pData, nSize)", aError == rtl_Digest_E_None); 582 583 rtl_digest_update( handle, pData, nSize ); 584 585 sal_uInt32 nKeyLen = rtl_digest_queryLength( handle ); 586 sal_uInt8 *pKeyBuffer = new sal_uInt8[ nKeyLen ]; 587 588 rtl_digest_get( handle, pKeyBuffer, nKeyLen ); 589 rtl::OString aSum = createHex(pKeyBuffer, nKeyLen); 590 delete [] pKeyBuffer; 591 592 t_print("MD2 Sum: %s\n", aSum.getStr()); 593 // LLA: how to check right values 594 // samples? 595 596 rtl_digest_destroy( handle ); 597 } 598 599 void init_MD5() 600 { 601 rtlDigest handle = rtl_digest_create( rtl_Digest_AlgorithmMD5 ); 602 603 rtl::OString aMsg = sSampleString; 604 const sal_uInt8 *pData = (const sal_uInt8*)aMsg.getStr(); 605 sal_uInt32 nSize = ( aMsg.getLength() ); 606 607 rtlDigestError aError = rtl_digest_init(handle, pData, nSize); 608 609 CPPUNIT_ASSERT_MESSAGE("init(handle, pData, nSize)", aError == rtl_Digest_E_None); 610 611 rtl_digest_update( handle, pData, nSize ); 612 613 sal_uInt32 nKeyLen = rtl_digest_queryLength( handle ); 614 sal_uInt8 *pKeyBuffer = new sal_uInt8[ nKeyLen ]; 615 616 rtl_digest_get( handle, pKeyBuffer, nKeyLen ); 617 rtl::OString aSum = createHex(pKeyBuffer, nKeyLen); 618 delete [] pKeyBuffer; 619 620 t_print("MD5 Sum: %s\n", aSum.getStr()); 621 // LLA: how to check right values 622 // samples? 623 624 rtl_digest_destroy( handle ); 625 } 626 627 void init_SHA() 628 { 629 rtlDigest handle = rtl_digest_create( rtl_Digest_AlgorithmSHA ); 630 631 rtl::OString aMsg = sSampleString; 632 const sal_uInt8 *pData = (const sal_uInt8*)aMsg.getStr(); 633 sal_uInt32 nSize = ( aMsg.getLength() ); 634 635 rtlDigestError aError = rtl_digest_init(handle, pData, nSize); 636 637 CPPUNIT_ASSERT_MESSAGE("init(handle, pData, nSize)", aError == rtl_Digest_E_None); 638 639 rtl_digest_update( handle, pData, nSize ); 640 641 sal_uInt32 nKeyLen = rtl_digest_queryLength( handle ); 642 sal_uInt8 *pKeyBuffer = new sal_uInt8[ nKeyLen ]; 643 644 rtl_digest_get( handle, pKeyBuffer, nKeyLen ); 645 rtl::OString aSum = createHex(pKeyBuffer, nKeyLen); 646 delete [] pKeyBuffer; 647 648 t_print("SHA Sum: %s\n", aSum.getStr()); 649 // LLA: how to check right values 650 // samples? 651 652 rtl_digest_destroy( handle ); 653 } 654 void init_SHA1() 655 { 656 rtlDigest handle = rtl_digest_create( rtl_Digest_AlgorithmSHA1 ); 657 658 rtl::OString aMsg = sSampleString; 659 const sal_uInt8 *pData = (const sal_uInt8*)aMsg.getStr(); 660 sal_uInt32 nSize = ( aMsg.getLength() ); 661 662 rtlDigestError aError = rtl_digest_init(handle, pData, nSize); 663 664 CPPUNIT_ASSERT_MESSAGE("init(handle, pData, nSize)", aError == rtl_Digest_E_None); 665 666 rtl_digest_update( handle, pData, nSize ); 667 668 sal_uInt32 nKeyLen = rtl_digest_queryLength( handle ); 669 sal_uInt8 *pKeyBuffer = new sal_uInt8[ nKeyLen ]; 670 671 rtl_digest_get( handle, pKeyBuffer, nKeyLen ); 672 rtl::OString aSum = createHex(pKeyBuffer, nKeyLen); 673 delete [] pKeyBuffer; 674 675 t_print("SHA1 Sum: %s\n", aSum.getStr()); 676 // LLA: how to check right values 677 // samples? 678 679 rtl_digest_destroy( handle ); 680 } 681 void init_HMAC_MD5() 682 { 683 rtlDigest handle = rtl_digest_create( rtl_Digest_AlgorithmHMAC_MD5 ); 684 685 rtl::OString aMsg = sSampleString; 686 const sal_uInt8 *pData = (const sal_uInt8*)aMsg.getStr(); 687 sal_uInt32 nSize = ( aMsg.getLength() ); 688 689 sal_uInt32 nKeyLen = rtl_digest_queryLength( handle ); 690 CPPUNIT_ASSERT_MESSAGE( "Keylen must be greater 0", nKeyLen ); 691 692 sal_uInt8 *pKeyBuffer = new sal_uInt8[ nKeyLen ]; 693 CPPUNIT_ASSERT( pKeyBuffer ); 694 memset(pKeyBuffer, 0, nKeyLen); 695 696 rtlDigestError aError = rtl_digest_init(handle, pKeyBuffer, nKeyLen ); 697 698 CPPUNIT_ASSERT_MESSAGE("init(handle, pData, nSize)", aError == rtl_Digest_E_None); 699 700 rtl_digest_update( handle, pData, nSize ); 701 702 rtl_digest_get( handle, pKeyBuffer, nKeyLen ); 703 rtl::OString aSum = createHex(pKeyBuffer, nKeyLen); 704 delete [] pKeyBuffer; 705 706 t_print("HMAC_MD5 Sum: %s\n", aSum.getStr()); 707 // LLA: how to check right values 708 // samples? 709 710 rtl_digest_destroy( handle ); 711 } 712 void init_HMAC_SHA1() 713 { 714 rtlDigest handle = rtl_digest_create( rtl_Digest_AlgorithmHMAC_SHA1 ); 715 716 rtl::OString aMsg = sSampleString; 717 const sal_uInt8 *pData = (const sal_uInt8*)aMsg.getStr(); 718 sal_uInt32 nSize = ( aMsg.getLength() ); 719 720 sal_uInt32 nKeyLen = rtl_digest_queryLength( handle ); 721 CPPUNIT_ASSERT_MESSAGE( "Keylen must be greater 0", nKeyLen ); 722 723 sal_uInt8 *pKeyBuffer = new sal_uInt8[ nKeyLen ]; 724 CPPUNIT_ASSERT( pKeyBuffer ); 725 memset(pKeyBuffer, 0, nKeyLen); 726 727 rtlDigestError aError = rtl_digest_init(handle, pKeyBuffer, nKeyLen ); 728 729 CPPUNIT_ASSERT_MESSAGE("init(handle, pData, nSize)", aError == rtl_Digest_E_None); 730 731 rtl_digest_update( handle, pData, nSize ); 732 733 rtl_digest_get( handle, pKeyBuffer, nKeyLen ); 734 rtl::OString aSum = createHex(pKeyBuffer, nKeyLen); 735 delete [] pKeyBuffer; 736 737 t_print("HMAC_SHA1 Sum: %s\n", aSum.getStr()); 738 // LLA: how to check right values 739 // samples? 740 741 rtl_digest_destroy( handle ); 742 } 743 744 745 // Change the following lines only, if you add, remove or rename 746 // member functions of the current class, 747 // because these macros are need by auto register mechanism. 748 749 CPPUNIT_TEST_SUITE(init); 750 CPPUNIT_TEST( init_000 ); 751 CPPUNIT_TEST( init_001 ); 752 CPPUNIT_TEST( init_MD2 ); 753 CPPUNIT_TEST( init_MD5 ); 754 CPPUNIT_TEST( init_SHA ); 755 CPPUNIT_TEST( init_SHA1 ); 756 CPPUNIT_TEST( init_HMAC_MD5 ); 757 CPPUNIT_TEST( init_HMAC_SHA1 ); 758 CPPUNIT_TEST_SUITE_END(); 759 }; // class init 760 761 // ------------------------------------ 762 763 rtl::OString getMD5Sum(rtl::OString const& _aMsg ) 764 { 765 rtlDigest handle = rtl_digest_create( rtl_Digest_AlgorithmMD5 ); 766 767 const sal_uInt8 *pData = (const sal_uInt8*)_aMsg.getStr(); 768 sal_uInt32 nSize = ( _aMsg.getLength() ); 769 770 rtl_digest_init(handle, pData, nSize); 771 rtl_digest_update( handle, pData, nSize ); 772 773 sal_uInt32 nMD5KeyLen = rtl_digest_queryLength( handle ); 774 sal_uInt8 *pMD5KeyBuffer = new sal_uInt8[ nMD5KeyLen ]; 775 776 rtl_digest_get( handle, pMD5KeyBuffer, nMD5KeyLen ); 777 rtl::OString aMD5Sum = createHex(pMD5KeyBuffer, nMD5KeyLen); 778 delete [] pMD5KeyBuffer; 779 780 rtl_digest_destroy( handle ); 781 return aMD5Sum; 782 } 783 784 // ----------------------------------------------------------------------------- 785 786 class equalTests : public CppUnit::TestFixture 787 { 788 public: 789 // initialise your test code values here. 790 void setUp() 791 { 792 } 793 794 void tearDown() 795 { 796 } 797 798 // ------------------------------------ 799 void equal_001() 800 { 801 rtl::OString aMsg1 = sSampleString; 802 rtl::OString aMsg2 = sSampleString; 803 804 rtl::OString aMsgMD5Sum1 = getMD5Sum(aMsg1); 805 rtl::OString aMsgMD5Sum2 = getMD5Sum(aMsg2); 806 807 CPPUNIT_ASSERT_MESSAGE("md5sum must have a length", aMsgMD5Sum1.getLength() == 32 && aMsgMD5Sum2.getLength() == 32 ); 808 CPPUNIT_ASSERT_MESSAGE("source is the same, dest must be also the same", aMsgMD5Sum1.equals(aMsgMD5Sum2) == sal_True); 809 } 810 // ------------------------------------ 811 void equal_002() 812 { 813 rtl::OString aMsg1 = sSampleString; 814 rtl::OString aMsg2 = sSampleString_only_one_diff; 815 816 rtl::OString aMsgMD5Sum1 = getMD5Sum(aMsg1); 817 rtl::OString aMsgMD5Sum2 = getMD5Sum(aMsg2); 818 819 CPPUNIT_ASSERT_MESSAGE("md5sum must have a length", aMsgMD5Sum1.getLength() == 32 && aMsgMD5Sum2.getLength() == 32 ); 820 CPPUNIT_ASSERT_MESSAGE("differ only in one char", aMsgMD5Sum1.equals(aMsgMD5Sum2) == sal_False); 821 } 822 823 // Change the following lines only, if you add, remove or rename 824 // member functions of the current class, 825 // because these macros are need by auto register mechanism. 826 827 CPPUNIT_TEST_SUITE(equalTests); 828 CPPUNIT_TEST( equal_001 ); 829 CPPUNIT_TEST( equal_002 ); 830 CPPUNIT_TEST_SUITE_END(); 831 }; // class create 832 833 834 // ----------------------------------------------------------------------------- 835 class digest_MD2 : public CppUnit::TestFixture 836 { 837 public: 838 // initialise your test code values here. 839 void setUp() 840 { 841 } 842 843 void tearDown() 844 { 845 } 846 847 // ------------------------------------ 848 void MD2_001() 849 { 850 rtl::OString aMsg1 = sSampleString; 851 852 sal_uInt8 *pBuffer = new sal_uInt8[ RTL_DIGEST_LENGTH_MD2 ]; 853 CPPUNIT_ASSERT( pBuffer ); 854 memset(pBuffer, 0, RTL_DIGEST_LENGTH_MD2 ); 855 856 sal_uInt8 *pMsg1 = (sal_uInt8*)aMsg1.getStr(); 857 sal_Int32 nLen = aMsg1.getLength(); 858 859 rtlDigestError aError = rtl_digest_MD2(pMsg1, nLen, pBuffer, RTL_DIGEST_LENGTH_MD2); 860 861 CPPUNIT_ASSERT(aError == rtl_Digest_E_None ); 862 863 rtl::OString aStr = createHex(pBuffer, RTL_DIGEST_LENGTH_MD2); 864 t_print("Decrypt MD2: %s\n", aStr.getStr()); 865 CPPUNIT_ASSERT_MESSAGE("checksum of sample string is wrong. Code changes or sample problems, please check.", aStr.equals(sSampleString_MD2) ); 866 867 delete [] pBuffer; 868 } 869 870 // Change the following lines only, if you add, remove or rename 871 // member functions of the current class, 872 // because these macros are need by auto register mechanism. 873 874 CPPUNIT_TEST_SUITE(digest_MD2); 875 CPPUNIT_TEST( MD2_001 ); 876 CPPUNIT_TEST_SUITE_END(); 877 }; // class create 878 // ----------------------------------------------------------------------------- 879 class digest_MD5 : public CppUnit::TestFixture 880 { 881 public: 882 // initialise your test code values here. 883 void setUp() 884 { 885 } 886 887 void tearDown() 888 { 889 } 890 // ------------------------------------ 891 void MD5_001() 892 { 893 rtl::OString aMsg1 = sSampleString; 894 895 sal_uInt8 *pBuffer = new sal_uInt8[ RTL_DIGEST_LENGTH_MD5 ]; 896 CPPUNIT_ASSERT( pBuffer ); 897 memset(pBuffer, 0, RTL_DIGEST_LENGTH_MD5 ); 898 899 sal_uInt8 *pMsg1 = (sal_uInt8*)aMsg1.getStr(); 900 sal_Int32 nLen = aMsg1.getLength(); 901 902 rtlDigestError aError = rtl_digest_MD5(pMsg1, nLen, pBuffer, RTL_DIGEST_LENGTH_MD5); 903 904 CPPUNIT_ASSERT(aError == rtl_Digest_E_None ); 905 906 rtl::OString aStr = createHex(pBuffer, RTL_DIGEST_LENGTH_MD5); 907 t_print("Decrypt MD5: %s\n", aStr.getStr()); 908 CPPUNIT_ASSERT_MESSAGE("checksum of sample string is wrong. Code changes or sample problems, please check.", aStr.equals(sSampleString_MD5) ); 909 910 delete [] pBuffer; 911 } 912 913 // Change the following lines only, if you add, remove or rename 914 // member functions of the current class, 915 // because these macros are need by auto register mechanism. 916 917 CPPUNIT_TEST_SUITE(digest_MD5); 918 CPPUNIT_TEST( MD5_001 ); 919 CPPUNIT_TEST_SUITE_END(); 920 }; // class create 921 922 // ----------------------------------------------------------------------------- 923 class digest_SHA : public CppUnit::TestFixture 924 { 925 public: 926 // initialise your test code values here. 927 void setUp() 928 { 929 } 930 931 void tearDown() 932 { 933 } 934 935 // ------------------------------------ 936 void SHA_001() 937 { 938 rtl::OString aMsg1 = sSampleString; 939 940 sal_uInt8 *pBuffer = new sal_uInt8[ RTL_DIGEST_LENGTH_SHA ]; 941 CPPUNIT_ASSERT( pBuffer ); 942 memset(pBuffer, 0, RTL_DIGEST_LENGTH_SHA); 943 944 sal_uInt8 *pMsg1 = (sal_uInt8*)aMsg1.getStr(); 945 sal_Int32 nLen = aMsg1.getLength(); 946 947 rtlDigestError aError = rtl_digest_SHA(pMsg1, nLen, pBuffer, RTL_DIGEST_LENGTH_SHA); 948 949 CPPUNIT_ASSERT(aError == rtl_Digest_E_None ); 950 951 rtl::OString aStr = createHex(pBuffer, RTL_DIGEST_LENGTH_SHA); 952 t_print("Decrypt SHA: %s\n", aStr.getStr()); 953 CPPUNIT_ASSERT_MESSAGE("checksum of sample string is wrong. Code changes or sample problems, please check.", aStr.equals(sSampleString_SHA) ); 954 955 delete [] pBuffer; 956 } 957 958 // Change the following lines only, if you add, remove or rename 959 // member functions of the current class, 960 // because these macros are need by auto register mechanism. 961 962 CPPUNIT_TEST_SUITE(digest_SHA); 963 CPPUNIT_TEST( SHA_001 ); 964 CPPUNIT_TEST_SUITE_END(); 965 }; // class create 966 967 // ----------------------------------------------------------------------------- 968 class digest_SHA1 : public CppUnit::TestFixture 969 { 970 public: 971 // initialise your test code values here. 972 void setUp() 973 { 974 } 975 976 void tearDown() 977 { 978 } 979 980 // ------------------------------------ 981 void SHA1_001() 982 { 983 rtl::OString aMsg1 = sSampleString; 984 985 sal_uInt8 *pBuffer = new sal_uInt8[ RTL_DIGEST_LENGTH_SHA1 ]; 986 CPPUNIT_ASSERT( pBuffer ); 987 memset(pBuffer, 0, RTL_DIGEST_LENGTH_SHA1); 988 989 sal_uInt8 *pMsg1 = (sal_uInt8*)aMsg1.getStr(); 990 sal_Int32 nLen = aMsg1.getLength(); 991 992 rtlDigestError aError = rtl_digest_SHA1(pMsg1, nLen, pBuffer, RTL_DIGEST_LENGTH_SHA1); 993 994 CPPUNIT_ASSERT(aError == rtl_Digest_E_None ); 995 996 rtl::OString aStr = createHex(pBuffer, RTL_DIGEST_LENGTH_SHA1); 997 t_print("Decrypt SHA1: %s\n", aStr.getStr()); 998 CPPUNIT_ASSERT_MESSAGE("checksum of sample string is wrong. Code changes or sample problems, please check.", aStr.equals(sSampleString_SHA1) ); 999 1000 delete [] pBuffer; 1001 } 1002 // Change the following lines only, if you add, remove or rename 1003 // member functions of the current class, 1004 // because these macros are need by auto register mechanism. 1005 1006 CPPUNIT_TEST_SUITE(digest_SHA1); 1007 CPPUNIT_TEST( SHA1_001 ); 1008 CPPUNIT_TEST_SUITE_END(); 1009 }; // class create 1010 // ----------------------------------------------------------------------------- 1011 class digest_HMAC_MD5 : public CppUnit::TestFixture 1012 { 1013 public: 1014 // initialise your test code values here. 1015 void setUp() 1016 { 1017 } 1018 1019 void tearDown() 1020 { 1021 } 1022 1023 // ------------------------------------ 1024 void HMAC_MD5_001() 1025 { 1026 rtl::OString aMsg1 = sSampleString; 1027 1028 sal_uInt8 *pKeyBuffer = new sal_uInt8[ RTL_DIGEST_LENGTH_HMAC_MD5 ]; 1029 CPPUNIT_ASSERT( pKeyBuffer ); 1030 memset(pKeyBuffer, 0, RTL_DIGEST_LENGTH_HMAC_MD5); 1031 1032 sal_uInt8 *pBuffer = new sal_uInt8[ RTL_DIGEST_LENGTH_HMAC_MD5 ]; 1033 CPPUNIT_ASSERT( pBuffer ); 1034 memset(pBuffer, 0, RTL_DIGEST_LENGTH_HMAC_MD5); 1035 1036 sal_uInt8 *pMsg1 = (sal_uInt8*)aMsg1.getStr(); 1037 sal_Int32 nLen = aMsg1.getLength(); 1038 1039 rtlDigestError aError = rtl_digest_HMAC_MD5(pKeyBuffer, RTL_DIGEST_LENGTH_HMAC_MD5, pMsg1, nLen, pBuffer, RTL_DIGEST_LENGTH_HMAC_MD5); 1040 1041 CPPUNIT_ASSERT(aError == rtl_Digest_E_None ); 1042 1043 rtl::OString aStr = createHex(pBuffer, RTL_DIGEST_LENGTH_HMAC_MD5); 1044 t_print("Decrypt HMAC_MD5: %s\n", aStr.getStr()); 1045 CPPUNIT_ASSERT_MESSAGE("md5sum of sample string is wrong. Code changes or sample problems, please check.", aStr.equals(sSampleString_HMAC_MD5) ); 1046 1047 delete [] pBuffer; 1048 } 1049 // Change the following lines only, if you add, remove or rename 1050 // member functions of the current class, 1051 // because these macros are need by auto register mechanism. 1052 1053 CPPUNIT_TEST_SUITE(digest_HMAC_MD5); 1054 CPPUNIT_TEST( HMAC_MD5_001 ); 1055 CPPUNIT_TEST_SUITE_END(); 1056 }; // class create 1057 // ----------------------------------------------------------------------------- 1058 class digest_HMAC_SHA1 : public CppUnit::TestFixture 1059 { 1060 public: 1061 // initialise your test code values here. 1062 void setUp() 1063 { 1064 } 1065 1066 void tearDown() 1067 { 1068 } 1069 1070 // ------------------------------------ 1071 void HMAC_SHA1_001() 1072 { 1073 rtl::OString aMsg1 = sSampleString; 1074 1075 sal_uInt8 *pKeyBuffer = new sal_uInt8[ RTL_DIGEST_LENGTH_HMAC_SHA1 ]; 1076 CPPUNIT_ASSERT( pKeyBuffer ); 1077 memset(pKeyBuffer, 0, RTL_DIGEST_LENGTH_HMAC_SHA1); 1078 1079 sal_uInt8 *pBuffer = new sal_uInt8[ RTL_DIGEST_LENGTH_HMAC_SHA1 ]; 1080 CPPUNIT_ASSERT( pBuffer ); 1081 memset(pBuffer, 0, RTL_DIGEST_LENGTH_HMAC_SHA1); 1082 1083 sal_uInt8 *pMsg1 = (sal_uInt8*)aMsg1.getStr(); 1084 sal_Int32 nLen = aMsg1.getLength(); 1085 1086 rtlDigestError aError = rtl_digest_HMAC_SHA1(pKeyBuffer, RTL_DIGEST_LENGTH_HMAC_SHA1, pMsg1, nLen, pBuffer, RTL_DIGEST_LENGTH_HMAC_SHA1); 1087 1088 CPPUNIT_ASSERT(aError == rtl_Digest_E_None ); 1089 1090 rtl::OString aStr = createHex(pBuffer, RTL_DIGEST_LENGTH_HMAC_SHA1); 1091 t_print("Decrypt HMAC_SHA1: %s\n", aStr.getStr()); 1092 CPPUNIT_ASSERT_MESSAGE("md5sum of sample string is wrong. Code changes or sample problems, please check.", aStr.equals(sSampleString_HMAC_SHA1) ); 1093 1094 delete [] pBuffer; 1095 } 1096 1097 // Change the following lines only, if you add, remove or rename 1098 // member functions of the current class, 1099 // because these macros are need by auto register mechanism. 1100 1101 CPPUNIT_TEST_SUITE(digest_HMAC_SHA1); 1102 CPPUNIT_TEST( HMAC_SHA1_001 ); 1103 CPPUNIT_TEST_SUITE_END(); 1104 }; // class create 1105 // ----------------------------------------------------------------------------- 1106 class digest_PBKDF2 : public CppUnit::TestFixture 1107 { 1108 public: 1109 // initialise your test code values here. 1110 void setUp() 1111 { 1112 } 1113 1114 void tearDown() 1115 { 1116 } 1117 1118 // ------------------------------------ 1119 rtl::OString /* key */ run_check_PBKDF2(rtl::OString const& _sPassword, bool _bClearSalt, sal_uInt32 _nCount) 1120 { 1121 sal_uInt32 nKeyLen = RTL_DIGEST_LENGTH_HMAC_SHA1; 1122 sal_uInt8 *pKeyBuffer = new sal_uInt8[ nKeyLen ]; 1123 CPPUNIT_ASSERT( pKeyBuffer ); 1124 memset(pKeyBuffer, 0, nKeyLen); 1125 1126 sal_uInt8 *pPassword = (sal_uInt8*)_sPassword.getStr(); 1127 sal_Int32 nPasswordLen = _sPassword.getLength(); 1128 1129 sal_uInt32 nSaltDataLen = RTL_DIGEST_LENGTH_HMAC_SHA1; 1130 sal_uInt8 *pSaltData = new sal_uInt8[ nSaltDataLen ]; 1131 CPPUNIT_ASSERT( pSaltData ); 1132 memset(pSaltData, 0, nSaltDataLen); 1133 1134 if (! _bClearSalt) 1135 { 1136 // wilful contamination 1137 pSaltData[0] = 1; 1138 } 1139 1140 rtlDigestError aError = rtl_digest_PBKDF2(pKeyBuffer, nKeyLen, pPassword, nPasswordLen, pSaltData, nSaltDataLen, _nCount); 1141 1142 CPPUNIT_ASSERT(aError == rtl_Digest_E_None ); 1143 1144 rtl::OString aKey = createHex(pKeyBuffer, nKeyLen); 1145 t_print("Key: %s\n", aKey.getStr()); 1146 1147 // rtl::OString sSalt = createHex(pSaltData, nSaltDataLen); 1148 // t_print("Salt: %s\n", sSalt.getStr()); 1149 1150 // CPPUNIT_ASSERT_MESSAGE("md5sum of sample string is wrong. Code changes or sample problems, please check.", aStr.equals(sSampleString_PBKDF2) ); 1151 1152 delete [] pSaltData; 1153 delete [] pKeyBuffer; 1154 return aKey; 1155 } 1156 1157 void PBKDF2_001() 1158 { 1159 rtl::OString aPassword = "Password"; 1160 1161 // all permutations 1162 run_check_PBKDF2(aPassword, false, 1); 1163 run_check_PBKDF2(aPassword, false, 2); 1164 run_check_PBKDF2(aPassword, true, 1); 1165 run_check_PBKDF2(aPassword, true, 2); 1166 run_check_PBKDF2(aPassword, false, 3); 1167 run_check_PBKDF2(aPassword, false, 4); 1168 run_check_PBKDF2(aPassword, true, 3); 1169 run_check_PBKDF2(aPassword, true, 4); 1170 } 1171 // Change the following lines only, if you add, remove or rename 1172 // member functions of the current class, 1173 // because these macros are need by auto register mechanism. 1174 1175 CPPUNIT_TEST_SUITE(digest_PBKDF2); 1176 CPPUNIT_TEST( PBKDF2_001 ); 1177 CPPUNIT_TEST_SUITE_END(); 1178 }; // class create 1179 // ----------------------------------------------------------------------------- 1180 1181 class update : public CppUnit::TestFixture 1182 { 1183 public: 1184 // initialise your test code values here. 1185 void setUp() 1186 { 1187 } 1188 1189 void tearDown() 1190 { 1191 } 1192 1193 void update_000() 1194 { 1195 rtlDigest aHandle = NULL; 1196 rtlDigestError aError = rtl_digest_update(aHandle, NULL, 0); 1197 CPPUNIT_ASSERT_MESSAGE("does not handle wrong parameter", aError == rtl_Digest_E_Argument ); 1198 } 1199 1200 void updateMD2_000() 1201 { 1202 rtlDigest aHandle = NULL; 1203 rtlDigestError aError = rtl_digest_updateMD2(aHandle, NULL, 0); 1204 CPPUNIT_ASSERT_MESSAGE("does not handle wrong parameter", aError == rtl_Digest_E_Argument ); 1205 } 1206 1207 void updateMD2_001() 1208 { 1209 rtlDigest aHandle = rtl_digest_create( rtl_Digest_AlgorithmMD2 ); 1210 CPPUNIT_ASSERT_MESSAGE("create with rtl_Digest_AlgorithmMD2", aHandle != 0); 1211 1212 rtl::OString aMsg = sSampleString; 1213 const sal_uInt8* pData = (const sal_uInt8*)aMsg.getStr(); 1214 1215 rtlDigestError aError = rtl_digest_updateMD2(aHandle, NULL, 0); 1216 CPPUNIT_ASSERT_MESSAGE("handle parameter 'pData' wrong", aError == rtl_Digest_E_Argument ); 1217 1218 /* rtlDigestError */ aError = rtl_digest_updateMD2(aHandle, pData, 0); 1219 CPPUNIT_ASSERT_MESSAGE("handle parameter 'nSize' wrong", aError == rtl_Digest_E_None ); 1220 1221 rtl_digest_destroyMD2(aHandle); 1222 } 1223 void updateMD5_000() 1224 { 1225 rtlDigest aHandle = NULL; 1226 rtlDigestError aError = rtl_digest_updateMD5(aHandle, NULL, 0); 1227 CPPUNIT_ASSERT_MESSAGE("does not handle wrong parameter", aError == rtl_Digest_E_Argument ); 1228 } 1229 1230 void updateMD5_001() 1231 { 1232 // use wrong Algorithm!!! This is volitional! 1233 rtlDigest aHandle = rtl_digest_create( rtl_Digest_AlgorithmMD2 ); 1234 CPPUNIT_ASSERT_MESSAGE("create with rtl_Digest_AlgorithmMD2", aHandle != 0); 1235 1236 rtl::OString aMsg = sSampleString; 1237 const sal_uInt8* pData = (const sal_uInt8*)aMsg.getStr(); 1238 sal_uInt32 nSize = ( aMsg.getLength() ); 1239 1240 rtlDigestError aError = rtl_digest_updateMD5(aHandle, pData, nSize); 1241 CPPUNIT_ASSERT_MESSAGE("handle parameter 'handle' wrong", aError == rtl_Digest_E_Algorithm ); 1242 1243 rtl_digest_destroyMD5(aHandle); 1244 } 1245 1246 void updateMD5_002() 1247 { 1248 rtlDigest aHandle = rtl_digest_create( rtl_Digest_AlgorithmMD5 ); 1249 CPPUNIT_ASSERT_MESSAGE("create with rtl_Digest_AlgorithmMD5", aHandle != 0); 1250 1251 rtl::OString aMsg = sSampleString; 1252 const sal_uInt8* pData = (const sal_uInt8*)aMsg.getStr(); 1253 1254 rtlDigestError aError = rtl_digest_updateMD5(aHandle, NULL, 0); 1255 CPPUNIT_ASSERT_MESSAGE("handle parameter 'pData' wrong", aError == rtl_Digest_E_Argument ); 1256 1257 /* rtlDigestError */ aError = rtl_digest_updateMD5(aHandle, pData, 0); 1258 CPPUNIT_ASSERT_MESSAGE("handle parameter 'nSize' wrong", aError == rtl_Digest_E_None ); 1259 1260 rtl_digest_destroyMD5(aHandle); 1261 } 1262 1263 void updateSHA_000() 1264 { 1265 rtlDigest aHandle = NULL; 1266 rtlDigestError aError = rtl_digest_updateSHA(aHandle, NULL, 0); 1267 CPPUNIT_ASSERT_MESSAGE("does not handle wrong parameter", aError == rtl_Digest_E_Argument ); 1268 } 1269 1270 void updateSHA1_000() 1271 { 1272 rtlDigest aHandle = NULL; 1273 rtlDigestError aError = rtl_digest_updateSHA1(aHandle, NULL, 0); 1274 CPPUNIT_ASSERT_MESSAGE("does not handle wrong parameter", aError == rtl_Digest_E_Argument ); 1275 } 1276 1277 void updateHMAC_MD5_000() 1278 { 1279 rtlDigest aHandle = NULL; 1280 rtlDigestError aError = rtl_digest_updateHMAC_MD5(aHandle, NULL, 0); 1281 CPPUNIT_ASSERT_MESSAGE("does not handle wrong parameter", aError == rtl_Digest_E_Argument ); 1282 } 1283 1284 void updateHMAC_SHA1_000() 1285 { 1286 rtlDigest aHandle = NULL; 1287 rtlDigestError aError = rtl_digest_updateHMAC_SHA1(aHandle, NULL, 0); 1288 CPPUNIT_ASSERT_MESSAGE("does not handle wrong parameter", aError == rtl_Digest_E_Argument ); 1289 } 1290 1291 // Change the following lines only, if you add, remove or rename 1292 // member functions of the current class, 1293 // because these macros are need by auto register mechanism. 1294 1295 CPPUNIT_TEST_SUITE(update); 1296 CPPUNIT_TEST(update_000); 1297 CPPUNIT_TEST(updateMD5_000); 1298 CPPUNIT_TEST(updateMD5_001); 1299 CPPUNIT_TEST(updateMD5_002); 1300 CPPUNIT_TEST(updateMD5_000); 1301 CPPUNIT_TEST(updateSHA_000); 1302 CPPUNIT_TEST(updateSHA1_000); 1303 CPPUNIT_TEST(updateHMAC_MD5_000); 1304 CPPUNIT_TEST(updateHMAC_SHA1_000); 1305 CPPUNIT_TEST_SUITE_END(); 1306 }; // class create 1307 // ----------------------------------------------------------------------------- 1308 1309 class get : public CppUnit::TestFixture 1310 { 1311 public: 1312 // initialise your test code values here. 1313 void setUp() 1314 { 1315 } 1316 1317 void tearDown() 1318 { 1319 } 1320 1321 void get_000() 1322 { 1323 rtlDigest aHandle = NULL; 1324 rtlDigestError aError = rtl_digest_get(aHandle, NULL, 0); 1325 CPPUNIT_ASSERT_MESSAGE("does not handle wrong parameter", aError == rtl_Digest_E_Argument ); 1326 } 1327 void getMD5_000() 1328 { 1329 rtlDigest aHandle = NULL; 1330 rtlDigestError aError = rtl_digest_getMD5(aHandle, NULL, 0); 1331 CPPUNIT_ASSERT_MESSAGE("does not handle wrong parameter", aError == rtl_Digest_E_Argument ); 1332 } 1333 void getMD5_001() 1334 { 1335 // test with wrong algorithm 1336 rtlDigest aHandle = rtl_digest_create( rtl_Digest_AlgorithmMD2 ); 1337 CPPUNIT_ASSERT_MESSAGE("create with rtl_Digest_AlgorithmMD2", aHandle != 0); 1338 1339 sal_uInt32 nKeyLen = rtl_digest_queryLength( aHandle ); 1340 sal_uInt8 *pKeyBuffer = new sal_uInt8[ nKeyLen ]; 1341 1342 rtlDigestError aError = rtl_digest_getMD5(aHandle, NULL, 0); 1343 CPPUNIT_ASSERT_MESSAGE("handle 2. parameter wrong", aError == rtl_Digest_E_Argument ); 1344 1345 /* rtlDigestError */ aError = rtl_digest_getMD5(aHandle, pKeyBuffer, 0); 1346 CPPUNIT_ASSERT_MESSAGE("handle parameter 'handle' wrong", aError == rtl_Digest_E_Algorithm ); 1347 1348 rtl_digest_destroyMD2(aHandle); 1349 } 1350 1351 void getMD5_002() 1352 { 1353 rtlDigest aHandle = rtl_digest_create( rtl_Digest_AlgorithmMD5 ); 1354 CPPUNIT_ASSERT_MESSAGE("create with rtl_Digest_AlgorithmMD5", aHandle != 0); 1355 1356 sal_uInt32 nKeyLen = rtl_digest_queryLength( aHandle ); 1357 sal_uInt8 *pKeyBuffer = new sal_uInt8[ nKeyLen ]; 1358 1359 rtlDigestError aError = rtl_digest_getMD5(aHandle, NULL /* pKeyBuffer */ , nKeyLen); 1360 CPPUNIT_ASSERT_MESSAGE("handle parameter 'pData' wrong", aError == rtl_Digest_E_Argument ); 1361 1362 /* rtlDigestError */ aError = rtl_digest_getMD5(aHandle, pKeyBuffer, 0); 1363 CPPUNIT_ASSERT_MESSAGE("handle parameter 'nSize' wrong", aError == rtl_Digest_E_BufferSize ); 1364 1365 rtl_digest_destroyMD5(aHandle); 1366 delete [] pKeyBuffer; 1367 } 1368 1369 // Change the following lines only, if you add, remove or rename 1370 // member functions of the current class, 1371 // because these macros are need by auto register mechanism. 1372 1373 CPPUNIT_TEST_SUITE(get); 1374 CPPUNIT_TEST(get_000); 1375 CPPUNIT_TEST(getMD5_000); 1376 CPPUNIT_TEST(getMD5_001); 1377 CPPUNIT_TEST(getMD5_002); 1378 CPPUNIT_TEST_SUITE_END(); 1379 }; // class create 1380 1381 // ----------------------------------------------------------------------------- 1382 class destroy : public CppUnit::TestFixture 1383 { 1384 public: 1385 // initialise your test code values here. 1386 void setUp() 1387 { 1388 } 1389 1390 void tearDown() 1391 { 1392 } 1393 1394 void destroy_001() 1395 { 1396 rtlDigest handle = rtl_digest_create( rtl_Digest_AlgorithmMD5 ); 1397 CPPUNIT_ASSERT_MESSAGE("create with rtl_Digest_AlgorithmMD5", handle != 0); 1398 1399 // not really testable 1400 // LLA: good will test. 1401 rtl_digest_destroy( handle ); 1402 } 1403 1404 // Change the following lines only, if you add, remove or rename 1405 // member functions of the current class, 1406 // because these macros are need by auto register mechanism. 1407 1408 CPPUNIT_TEST_SUITE(destroy); 1409 CPPUNIT_TEST(destroy_001); 1410 CPPUNIT_TEST_SUITE_END(); 1411 }; // class create 1412 // ----------------------------------------------------------------------------- 1413 1414 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_digest::create, "rtl_digest"); 1415 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_digest::createMD2, "rtl_digest"); 1416 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_digest::createMD5, "rtl_digest"); 1417 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_digest::createSHA, "rtl_digest"); 1418 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_digest::createSHA1, "rtl_digest"); 1419 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_digest::createHMAC_MD5, "rtl_digest"); 1420 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_digest::createHMAC_SHA1, "rtl_digest"); 1421 1422 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_digest::destroy, "rtl_digest"); 1423 1424 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_digest::queryAlgorithm, "rtl_digest"); 1425 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_digest::queryLength, "rtl_digest"); 1426 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_digest::init, "rtl_digest"); 1427 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_digest::equalTests, "rtl_digest"); 1428 1429 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_digest::digest_MD2, "rtl_digest"); 1430 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_digest::digest_MD5, "rtl_digest"); 1431 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_digest::digest_SHA, "rtl_digest"); 1432 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_digest::digest_SHA1, "rtl_digest"); 1433 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_digest::digest_HMAC_MD5, "rtl_digest"); 1434 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_digest::digest_HMAC_SHA1, "rtl_digest"); 1435 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_digest::digest_PBKDF2, "rtl_digest"); 1436 1437 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_digest::update, "rtl_digest"); 1438 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_digest::get, "rtl_digest"); 1439 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_digest::destroy, "rtl_digest"); 1440 } // namespace rtl_digest 1441 1442 1443 // ----------------------------------------------------------------------------- 1444 1445 // this macro creates an empty function, which will called by the RegisterAllFunctions() 1446 // to let the user the possibility to also register some functions by hand. 1447 NOADDITIONAL; 1448