xref: /aoo41x/main/sal/qa/rtl/cipher/rtl_cipher.cxx (revision 87d2adbc)
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 
createHex(sal_uInt8 * _pKeyBuffer,sal_uInt32 _nKeyLen)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.
setUp()59     void setUp()
60     {
61     }
62 
tearDown()63     void tearDown()
64     {
65     }
66 
create_001()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         }
create_002()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         }
create_003()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         }
create_004()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         }
create_005()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         }
create_006()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         }
create_007()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         }
create_008()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.
setUp()132     void setUp()
133     {
134     }
135 
tearDown()136     void tearDown()
137     {
138     }
139 
createBF_001()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         }
createBF_002()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         }
createBF_003()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         }
createBF_004()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.
setUp()180     void setUp()
181     {
182     }
183 
tearDown()184     void tearDown()
185     {
186     }
187 
test_encode(sal_uInt8 _nKeyValue,sal_uInt8 _nArgValue,rtl::OString const & _sPlainTextStr)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 
test_encode_and_decode(sal_uInt8 _nKeyValue,sal_uInt8 _nArgValue,rtl::OString const & _sPlainTextStr)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 
decode_001()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 
decode_002()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.
setUp()349     void setUp()
350     {
351     }
352 
tearDown()353     void tearDown()
354     {
355     }
356 
decodeBF_001()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.
setUp()373     void setUp()
374     {
375     }
376 
tearDown()377     void tearDown()
378     {
379     }
380 
destroy_001()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.
setUp()400     void setUp()
401     {
402     }
403 
tearDown()404     void tearDown()
405     {
406     }
407 
destroyBF_001()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.
setUp()429     void setUp()
430     {
431     }
432 
tearDown()433     void tearDown()
434     {
435     }
436 
test_encode(sal_uInt8 _nKeyValue,sal_uInt8 _nArgValue,sal_uInt8 _nDataValue)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 
encode_001()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.
setUp()510     void setUp()
511     {
512     }
513 
tearDown()514     void tearDown()
515     {
516     }
517 
encodeBF_001()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.
setUp()534     void setUp()
535     {
536     }
537 
tearDown()538     void tearDown()
539     {
540     }
541 
init_001()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 
init_002()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         }
init_003()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         }
init_004()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.
setUp()671     void setUp()
672     {
673     }
674 
tearDown()675     void tearDown()
676     {
677     }
678 
initBF_001()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