LCOV - code coverage report
Current view: top level - libcli/auth/tests - test_rc4_passwd_buffer.c (source / functions) Hit Total Coverage
Test: coverage report for master 6248eab5 Lines: 78 79 98.7 %
Date: 2021-08-25 13:27:56 Functions: 6 6 100.0 %

          Line data    Source code
       1             : /*
       2             :  * Unix SMB/CIFS implementation.
       3             :  *
       4             :  * Copyright (C) 2018-2019 Andreas Schneider <asn@samba.org>
       5             :  *
       6             :  * This program is free software; you can redistribute it and/or modify
       7             :  * it under the terms of the GNU General Public License as published by
       8             :  * the Free Software Foundation; either version 3 of the License, or
       9             :  * (at your option) any later version.
      10             :  *
      11             :  * This program is distributed in the hope that it will be useful,
      12             :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      13             :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      14             :  * GNU General Public License for more details.
      15             :  *
      16             :  * You should have received a copy of the GNU General Public License
      17             :  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
      18             :  */
      19             : 
      20             : #include <stdarg.h>
      21             : #include <stddef.h>
      22             : #include <stdint.h>
      23             : #include <setjmp.h>
      24             : #include <cmocka.h>
      25             : 
      26             : #include "includes.h"
      27             : #include "libcli/auth/libcli_auth.h"
      28             : #include "rpc_client/init_samr.h"
      29             : 
      30             : #define PASSWORD "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"
      31             : 
      32             : static const uint8_t encrypted_test_blob[] = {
      33             :         0x37, 0x8e, 0x1d, 0xd5, 0xd3, 0x9f, 0xca, 0x8e,
      34             :         0x2f, 0x2d, 0xee, 0xc3, 0xb5, 0x50, 0xcd, 0x4e,
      35             :         0xc9, 0x08, 0x04, 0x68, 0x32, 0xc3, 0xac, 0x8e,
      36             :         0x53, 0x69, 0xd6, 0xb7, 0x56, 0xcc, 0xc0, 0xbe,
      37             :         0x4e, 0x96, 0xa7, 0x74, 0xe9, 0xaa, 0x10, 0x3d,
      38             :         0xd5, 0x8c, 0xaa, 0x12, 0x56, 0xb6, 0xf1, 0x85,
      39             :         0x21, 0xfa, 0xe9, 0xa1, 0x76, 0xe6, 0xa5, 0x33,
      40             :         0x33, 0x2f, 0x47, 0x29, 0xd6, 0xbd, 0xde, 0x64,
      41             :         0x4d, 0x15, 0x3e, 0x6a, 0x11, 0x9b, 0x52, 0xbf,
      42             :         0x7e, 0x3a, 0xeb, 0x1c, 0x55, 0xd1, 0xb2, 0xa4,
      43             :         0x35, 0x03, 0x6c, 0x39, 0x61, 0x28, 0x98, 0xc3,
      44             :         0x2d, 0xd4, 0x70, 0x69, 0x8b, 0x83, 0xe9, 0x62,
      45             :         0xbe, 0xd8, 0x72, 0x4e, 0xdf, 0xd4, 0xe9, 0xe3,
      46             :         0x46, 0x2a, 0xf9, 0x3c, 0x0f, 0x41, 0x62, 0xe1,
      47             :         0x43, 0xf0, 0x91, 0xbe, 0x72, 0xa0, 0xc9, 0x08,
      48             :         0x73, 0x20, 0x1f, 0x0d, 0x68, 0x2e, 0x32, 0xa1,
      49             :         0xb8, 0x9b, 0x08, 0xa1, 0xb4, 0x81, 0x6b, 0xf1,
      50             :         0xde, 0x0c, 0x28, 0x34, 0xe2, 0x65, 0x62, 0x54,
      51             :         0xeb, 0xc0, 0x71, 0x14, 0xad, 0x36, 0x43, 0x0e,
      52             :         0x92, 0x4d, 0x11, 0xe8, 0xdd, 0x2d, 0x5f, 0x05,
      53             :         0xff, 0x07, 0xda, 0x81, 0x4e, 0x27, 0x42, 0xa8,
      54             :         0xa9, 0x64, 0x4c, 0x74, 0xc8, 0x05, 0xbb, 0x83,
      55             :         0x5a, 0xd9, 0x90, 0x3e, 0x0d, 0x9d, 0xe5, 0x2f,
      56             :         0x08, 0xf9, 0x1b, 0xbd, 0x26, 0xc3, 0x0d, 0xac,
      57             :         0x43, 0xd5, 0x17, 0xf2, 0x61, 0xf5, 0x74, 0x9b,
      58             :         0xf3, 0x5b, 0x5f, 0xe1, 0x8a, 0xa6, 0xfd, 0xdf,
      59             :         0xff, 0xb5, 0x8b, 0xf1, 0x26, 0xf7, 0xe0, 0xa7,
      60             :         0x4f, 0x5b, 0xb8, 0x6d, 0xeb, 0xf6, 0x52, 0x68,
      61             :         0x8d, 0xa3, 0xd4, 0x7f, 0x56, 0x43, 0xaa, 0xec,
      62             :         0x58, 0x47, 0x03, 0xee, 0x9b, 0x59, 0xd9, 0x78,
      63             :         0x9a, 0xfb, 0x9e, 0xe9, 0xa6, 0x61, 0x4e, 0x6d,
      64             :         0x92, 0x35, 0xd3, 0x37, 0x6e, 0xf2, 0x34, 0x39,
      65             :         0xd4, 0xd2, 0xeb, 0xcf, 0x1c, 0x10, 0xb3, 0x2b,
      66             :         0x3e, 0x07, 0x42, 0x3e, 0x20, 0x90, 0x07, 0x3e,
      67             :         0xc7, 0xed, 0xd4, 0xdf, 0x50, 0xe5, 0xff, 0xaf,
      68             :         0x05, 0xce, 0x29, 0xbe, 0x01, 0xf8, 0xb0, 0x30,
      69             :         0x96, 0xae, 0x1b, 0x62, 0x23, 0x93, 0x91, 0x1a,
      70             :         0x52, 0x98, 0xd9, 0x59, 0xb8, 0x11, 0xec, 0xb8,
      71             :         0xcf, 0x20, 0x32, 0x90, 0x9e, 0xf2, 0x06, 0x43,
      72             :         0xb8, 0x36, 0xe3, 0x33, 0x4e, 0x6f, 0x75, 0xeb,
      73             :         0xf7, 0x6c, 0xac, 0x06, 0x5f, 0x24, 0x8e, 0x4a,
      74             :         0x03, 0xdf, 0x50, 0x31, 0xaa, 0x91, 0xd5, 0x85,
      75             :         0x95, 0x78, 0x5b, 0xf4, 0x7f, 0x3e, 0xbc, 0x41,
      76             :         0xfa, 0x10, 0xd3, 0x0f, 0x86, 0x8b, 0x23, 0xed,
      77             :         0xfc, 0xcc, 0x3e, 0x7d, 0x8c, 0xb4, 0x7c, 0xec,
      78             :         0x04, 0x7d, 0x12, 0x53, 0xa1, 0x30, 0xc5, 0xac,
      79             :         0xf3, 0x1e, 0x54, 0x1f, 0x97, 0x05, 0x86, 0x74,
      80             :         0x51, 0x13, 0x45, 0x98, 0xb8, 0x50, 0x62, 0x18,
      81             :         0x0f, 0x6d, 0x66, 0xa4, 0x88, 0x31, 0x76, 0xa3,
      82             :         0xb0, 0x75, 0x55, 0x44, 0x18, 0x7c, 0x67, 0xc7,
      83             :         0x09, 0x9c, 0xab, 0x53, 0x49, 0xc0, 0xc9, 0x27,
      84             :         0x53, 0xa6, 0x99, 0x01, 0x10, 0x49, 0x67, 0x8e,
      85             :         0x5b, 0x12, 0x96, 0x40, 0x16, 0x39, 0x11, 0x53,
      86             :         0x44, 0x8f, 0xa9, 0xbe, 0x84, 0xbe, 0xe0, 0x45,
      87             :         0xe3, 0xfd, 0x48, 0x46, 0x43, 0x53, 0x13, 0x5f,
      88             :         0xfa, 0xcf, 0x09, 0x67, 0x90, 0xa3, 0x94, 0xaa,
      89             :         0x0d, 0x1f, 0xc2, 0xc3, 0xd4, 0x7e, 0xc8, 0x14,
      90             :         0xbe, 0x84, 0xa5, 0x55, 0xee, 0x49, 0x8e, 0x03,
      91             :         0x1d, 0xaf, 0xad, 0x65, 0x2f, 0xf0, 0xd5, 0x90,
      92             :         0x5e, 0x8d, 0x29, 0x40, 0xba, 0x57, 0x26, 0xa8,
      93             :         0x6c, 0x4b, 0x59, 0x40, 0x4e, 0xc2, 0xc4, 0x88,
      94             :         0x0a, 0x06, 0x2b, 0x6c, 0x2a, 0xc7, 0x3f, 0xfe,
      95             :         0x37, 0x2c, 0x41, 0x58, 0xfe, 0x7e, 0xaf, 0xd1,
      96             :         0xd9, 0xd2, 0x9c, 0xd7, 0x8a, 0x01, 0x0e, 0x8c,
      97             :         0x9e, 0x8b, 0x5d, 0x72, 0x54, 0x00, 0xbe, 0xb2,
      98             :         0x9a, 0xc7, 0xfd, 0x83, 0x1e, 0x9c, 0x79, 0xdd,
      99             :         0x15, 0x13, 0xdc, 0x15,
     100             : };
     101             : 
     102             : 
     103             : static const uint8_t encrypted_wkssvc_test_blob[] = {
     104             :         0x13, 0x79, 0x1f, 0x1a, 0x02, 0x15, 0x72, 0x1c,
     105             :         0xa6, 0x26, 0x37, 0xeb, 0x1d, 0x41, 0x7f, 0x76,
     106             :         0x11, 0x3f, 0x49, 0x4c, 0xf9, 0x69, 0x17, 0xc8,
     107             :         0x90, 0x92, 0x53, 0xb9, 0x3f, 0xcd, 0x06, 0xfe,
     108             :         0x5c, 0x17, 0x82, 0xbd, 0x86, 0xab, 0x49, 0xee,
     109             :         0x61, 0x76, 0x55, 0xc0, 0x10, 0x51, 0xcd, 0xd9,
     110             :         0x6f, 0x12, 0x86, 0xc6, 0x19, 0x59, 0x9a, 0x2f,
     111             :         0x27, 0x1d, 0x99, 0x30, 0x60, 0x0d, 0x65, 0xc6,
     112             :         0x43, 0xd6, 0xda, 0x6b, 0x66, 0x95, 0xd4, 0xca,
     113             :         0xf5, 0x04, 0xf7, 0x01, 0x5a, 0x55, 0xb0, 0x5e,
     114             :         0x72, 0x8a, 0x75, 0xe5, 0x33, 0x4c, 0xd8, 0xc4,
     115             :         0x0e, 0xf4, 0x6d, 0x23, 0xdd, 0x05, 0x90, 0xff,
     116             :         0xe0, 0x91, 0x7b, 0x62, 0x86, 0xee, 0x78, 0x31,
     117             :         0x07, 0xad, 0x8b, 0xf9, 0xdf, 0x6f, 0x8b, 0xbd,
     118             :         0x15, 0xde, 0x1b, 0xae, 0x84, 0x68, 0xe5, 0x41,
     119             :         0x7a, 0xe3, 0x47, 0x99, 0xba, 0x61, 0xe5, 0x51,
     120             :         0x64, 0x9a, 0xa0, 0x41, 0x44, 0xa1, 0x3a, 0x52,
     121             :         0x59, 0x7d, 0x6c, 0xcf, 0xcc, 0xf0, 0x11, 0xbc,
     122             :         0xb7, 0x51, 0xa9, 0xd8, 0xfd, 0xbf, 0x58, 0x77,
     123             :         0x28, 0x86, 0xa1, 0x27, 0x94, 0xe5, 0xf6, 0x1a,
     124             :         0x6b, 0x76, 0xf7, 0x72, 0x6e, 0x17, 0x09, 0xd8,
     125             :         0x3c, 0x6f, 0x39, 0x91, 0xea, 0x48, 0x98, 0xdc,
     126             :         0x1d, 0x50, 0x2e, 0x02, 0x6e, 0x7f, 0x80, 0x5d,
     127             :         0x6e, 0x96, 0xe1, 0xcf, 0x8b, 0x6b, 0xb6, 0xed,
     128             :         0xb4, 0x6a, 0x08, 0xd2, 0x45, 0x09, 0x88, 0x86,
     129             :         0x32, 0x58, 0xd8, 0x5e, 0x33, 0x8c, 0x29, 0x1a,
     130             :         0x8f, 0xc5, 0x54, 0x9b, 0xa8, 0x32, 0xb2, 0xc1,
     131             :         0x72, 0x14, 0x6c, 0x5d, 0x9d, 0xd3, 0xf2, 0x6c,
     132             :         0x6e, 0xa4, 0x84, 0x52, 0x26, 0x73, 0x7a, 0x30,
     133             :         0x56, 0x75, 0xef, 0xd1, 0x9d, 0xcd, 0xb7, 0x87,
     134             :         0xa9, 0x5c, 0xaf, 0xe6, 0xda, 0x1d, 0x3c, 0x9c,
     135             :         0xa3, 0xb1, 0x03, 0xb0, 0x8e, 0xf6, 0xc8, 0x8f,
     136             :         0x57, 0x1c, 0xce, 0x05, 0x54, 0x99, 0xf1, 0xf9,
     137             :         0x35, 0xe6, 0xf7, 0x67, 0x94, 0xb2, 0x67, 0x5b,
     138             :         0xe7, 0xa0, 0xa2, 0x1e, 0xa2, 0x74, 0xd3, 0x99,
     139             :         0x9c, 0xd5, 0xd9, 0x90, 0x86, 0x24, 0x0e, 0x1a,
     140             :         0x0d, 0xc8, 0x9e, 0x68, 0x4c, 0x43, 0x2f, 0x42,
     141             :         0xb1, 0x7c, 0xce, 0x1e, 0xb6, 0xac, 0x56, 0xb0,
     142             :         0x8d, 0x93, 0xf1, 0x53, 0x7d, 0x0e, 0x00, 0x46,
     143             :         0xba, 0x2e, 0x14, 0x7a, 0x0b, 0xaa, 0xcb, 0x07,
     144             :         0x9b, 0x09, 0x05, 0xa0, 0xd3, 0xa1, 0x80, 0xc2,
     145             :         0xd3, 0x59, 0x92, 0x27, 0x66, 0x1f, 0xdd, 0x76,
     146             :         0x36, 0xb3, 0x3c, 0xeb, 0xd7, 0x61, 0x94, 0xb1,
     147             :         0xf8, 0x3a, 0xe0, 0xba, 0x91, 0x0f, 0xef, 0x72,
     148             :         0x2b, 0x26, 0xc6, 0xb8, 0x6d, 0x0b, 0xdb, 0x60,
     149             :         0xf8, 0xb4, 0x98, 0xd7, 0x8b, 0x8d, 0xfb, 0xa7,
     150             :         0x4e, 0x27, 0xeb, 0x00, 0xe8, 0xf7, 0x5a, 0xec,
     151             :         0xf5, 0x60, 0x28, 0x37, 0xb2, 0xc4, 0x13, 0x48,
     152             :         0x2a, 0xe1, 0x34, 0xb2, 0x53, 0xcb, 0x44, 0x34,
     153             :         0x08, 0x7e, 0x56, 0x5c, 0x2b, 0x9b, 0xe2, 0xca,
     154             :         0x90, 0xb0, 0x57, 0xee, 0x10, 0x88, 0x39, 0x84,
     155             :         0xc6, 0x66, 0x07, 0x50, 0x63, 0xcc, 0x2a, 0x7c,
     156             :         0x99, 0x8c, 0x05, 0xf9, 0xf0, 0xb8, 0x62, 0xf0,
     157             :         0x92, 0xf7, 0x2a, 0x4a, 0x17, 0x14, 0x78, 0xa1,
     158             :         0x71, 0xb6, 0x42, 0xf0, 0x87, 0xa8, 0xa4, 0x48,
     159             :         0xeb, 0xdb, 0xed, 0x8a, 0x15, 0x19, 0x1a, 0xd9,
     160             :         0xfe, 0x6f, 0x07, 0x93, 0x5d, 0x39, 0xe8, 0x0e,
     161             :         0x47, 0xe6, 0x7a, 0x7d, 0x52, 0x2e, 0x40, 0x6f,
     162             :         0x31, 0x1b, 0xf6, 0x0c, 0xc2, 0x83, 0xae, 0xc1,
     163             :         0xf0, 0xf5, 0x71, 0xcd, 0xe2, 0xf5, 0x19, 0xb6,
     164             :         0xd8, 0xb0, 0x4d, 0xa9, 0x51, 0x1c, 0xb4, 0xaf,
     165             :         0x69, 0x9a, 0x89, 0xb6, 0x5b, 0x4d, 0xfa, 0x1b,
     166             :         0xca, 0xc8, 0x61, 0x92, 0x3a, 0xd6, 0x76, 0xad,
     167             :         0x5d, 0xa6, 0x17, 0x60, 0x3e, 0xea, 0x94, 0xcf,
     168             :         0x6d, 0x1b, 0x98, 0x5c, 0x19, 0x9e, 0x4e, 0xd3,
     169             :         0x21, 0x55, 0xda, 0xe3,
     170             : };
     171             : 
     172           1 : static void torture_decode_rc4_passwd_buffer(void **state)
     173             : {
     174           1 :         char *password_decoded = NULL;
     175           1 :         size_t password_decoded_len = 0;
     176           1 :         DATA_BLOB session_key = data_blob_const("SystemLibraryDTC", 16);
     177           1 :         struct samr_CryptPasswordEx out_pwd_buf = {
     178             :                 .data = {0},
     179             :         };
     180             :         NTSTATUS status;
     181             :         bool ok;
     182             : 
     183           1 :         memcpy(out_pwd_buf.data,
     184             :                encrypted_test_blob,
     185             :                sizeof(out_pwd_buf.data));
     186             : 
     187           1 :         status = decode_rc4_passwd_buffer(&session_key, &out_pwd_buf);
     188           1 :         assert_true(NT_STATUS_IS_OK(status));
     189             : 
     190           1 :         ok = decode_pw_buffer(NULL,
     191             :                               out_pwd_buf.data,
     192             :                               &password_decoded,
     193             :                               &password_decoded_len,
     194             :                               CH_UTF16);
     195           1 :         assert_true(ok);
     196           1 :         assert_int_equal(password_decoded_len, strlen(PASSWORD));
     197           1 :         assert_string_equal(password_decoded, PASSWORD);
     198           1 : }
     199             : 
     200           1 : static void torture_rc4_passwd_buffer(void **state)
     201             : {
     202           1 :         char *password_decoded = NULL;
     203           1 :         size_t password_decoded_len = 0;
     204           1 :         DATA_BLOB session_key = data_blob_const("SystemLibraryDTC", 16);
     205           1 :         struct samr_CryptPasswordEx out_pwd_buf = {
     206             :                 .data = {0},
     207             :         };
     208             :         NTSTATUS status;
     209             :         bool ok;
     210             : 
     211           1 :         status = init_samr_CryptPasswordEx(PASSWORD,
     212             :                                            &session_key,
     213             :                                            &out_pwd_buf);
     214           1 :         assert_true(NT_STATUS_IS_OK(status));
     215             : 
     216           1 :         status = decode_rc4_passwd_buffer(&session_key, &out_pwd_buf);
     217           1 :         assert_true(NT_STATUS_IS_OK(status));
     218             : 
     219           1 :         ok = decode_pw_buffer(NULL,
     220             :                               out_pwd_buf.data,
     221             :                               &password_decoded,
     222             :                               &password_decoded_len,
     223             :                               CH_UTF16);
     224           1 :         assert_true(ok);
     225           1 :         assert_int_equal(password_decoded_len, strlen(PASSWORD));
     226           1 :         assert_string_equal(password_decoded, PASSWORD);
     227           1 :         talloc_free(password_decoded);
     228           1 : }
     229             : 
     230           1 : static void torture_endode_decode_rc4_passwd_buffer(void **state)
     231             : {
     232           1 :         char *password_decoded = NULL;
     233           1 :         size_t password_decoded_len = 0;
     234           1 :         DATA_BLOB session_key = data_blob_const("SystemLibraryDTC", 16);
     235           1 :         struct samr_CryptPasswordEx out_pwd_buf = {
     236             :                 .data = {0},
     237             :         };
     238             :         NTSTATUS status;
     239             :         bool ok;
     240             : 
     241           1 :         status = encode_rc4_passwd_buffer(PASSWORD,
     242             :                                           &session_key,
     243             :                                           &out_pwd_buf);
     244           1 :         assert_true(NT_STATUS_IS_OK(status));
     245             : 
     246           1 :         status = decode_rc4_passwd_buffer(&session_key, &out_pwd_buf);
     247           1 :         assert_true(NT_STATUS_IS_OK(status));
     248             : 
     249           1 :         ok = decode_pw_buffer(NULL,
     250             :                               out_pwd_buf.data,
     251             :                               &password_decoded,
     252             :                               &password_decoded_len,
     253             :                               CH_UTF16);
     254           1 :         assert_true(ok);
     255           1 :         assert_int_equal(password_decoded_len, strlen(PASSWORD));
     256           1 :         assert_string_equal(password_decoded, PASSWORD);
     257           1 :         talloc_free(password_decoded);
     258           1 : }
     259             : 
     260           1 : static void torture_decode_wkssvc_join_password_buffer(void **state)
     261             : {
     262           1 :         DATA_BLOB session_key = data_blob_const("SystemLibraryDTC", 16);
     263           1 :         struct wkssvc_PasswordBuffer pwd_buf = {
     264             :                 .data = {0},
     265             :         };
     266           1 :         char *password_decoded = NULL;
     267           1 :         TALLOC_CTX *mem_ctx = NULL;
     268             :         WERROR werr;
     269             : 
     270           1 :         mem_ctx = talloc_new(NULL);
     271           1 :         assert_non_null(mem_ctx);
     272             : 
     273           1 :         memcpy(pwd_buf.data,
     274             :                encrypted_wkssvc_test_blob,
     275             :                sizeof(pwd_buf.data));
     276             : 
     277           1 :         werr = decode_wkssvc_join_password_buffer(mem_ctx,
     278             :                                                   &pwd_buf,
     279             :                                                   &session_key,
     280             :                                                   &password_decoded);
     281           1 :         assert_true(W_ERROR_IS_OK(werr));
     282           1 :         assert_non_null(password_decoded);
     283           1 :         assert_string_equal(password_decoded, PASSWORD);
     284             : 
     285           1 :         TALLOC_FREE(mem_ctx);
     286           1 : }
     287             : 
     288           1 : static void torture_wkssvc_join_password_buffer(void **state)
     289             : {
     290           1 :         DATA_BLOB session_key = data_blob_const("SystemLibraryDTC", 16);
     291           1 :         struct wkssvc_PasswordBuffer *pwd_buf = NULL;
     292           1 :         char *password_decoded = NULL;
     293           1 :         TALLOC_CTX *mem_ctx = NULL;
     294             :         WERROR werr;
     295             : 
     296           1 :         mem_ctx = talloc_new(NULL);
     297           1 :         assert_non_null(mem_ctx);
     298             : 
     299           1 :         werr = encode_wkssvc_join_password_buffer(mem_ctx,
     300             :                                                   PASSWORD,
     301             :                                                   &session_key,
     302             :                                                   &pwd_buf);
     303           1 :         assert_true(W_ERROR_IS_OK(werr));
     304           1 :         assert_non_null(pwd_buf);
     305             : 
     306           1 :         werr = decode_wkssvc_join_password_buffer(mem_ctx,
     307             :                                                   pwd_buf,
     308             :                                                   &session_key,
     309             :                                                   &password_decoded);
     310           1 :         assert_true(W_ERROR_IS_OK(werr));
     311           1 :         assert_non_null(password_decoded);
     312           1 :         assert_string_equal(password_decoded, PASSWORD);
     313             : 
     314           1 :         TALLOC_FREE(mem_ctx);
     315           1 : }
     316             : 
     317           1 : int main(int argc, char *argv[])
     318             : {
     319             :         int rc;
     320           1 :         const struct CMUnitTest tests[] = {
     321             :                 cmocka_unit_test(torture_decode_rc4_passwd_buffer),
     322             :                 cmocka_unit_test(torture_rc4_passwd_buffer),
     323             :                 cmocka_unit_test(torture_endode_decode_rc4_passwd_buffer),
     324             :                 cmocka_unit_test(torture_decode_wkssvc_join_password_buffer),
     325             :                 cmocka_unit_test(torture_wkssvc_join_password_buffer),
     326             :         };
     327             : 
     328           1 :         if (argc == 2) {
     329           0 :                 cmocka_set_test_filter(argv[1]);
     330             :         }
     331           1 :         cmocka_set_message_output(CM_OUTPUT_SUBUNIT);
     332             : 
     333           1 :         rc = cmocka_run_group_tests(tests, NULL, NULL);
     334             : 
     335             :         return rc;
     336             : }

Generated by: LCOV version 1.13