LCOV - code coverage report
Current view: top level - source4/dsdb/schema/tests - schema_syntax.c (source / functions) Hit Total Coverage
Test: coverage report for master 469b22b8 Lines: 116 122 95.1 %
Date: 2024-06-10 12:05:21 Functions: 14 14 100.0 %

          Line data    Source code
       1             : /* 
       2             :    Unix SMB/CIFS implementation.
       3             : 
       4             :    Test DSDB syntax functions
       5             : 
       6             :    Copyright (C) Andrew Bartlet <abartlet@samba.org> 2008
       7             :    
       8             :    This program is free software; you can redistribute it and/or modify
       9             :    it under the terms of the GNU General Public License as published by
      10             :    the Free Software Foundation; either version 3 of the License, or
      11             :    (at your option) any later version.
      12             :    
      13             :    This program is distributed in the hope that it will be useful,
      14             :    but WITHOUT ANY WARRANTY; without even the implied warranty of
      15             :    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      16             :    GNU General Public License for more details.
      17             :    
      18             :    You should have received a copy of the GNU General Public License
      19             :    along with this program.  If not, see <http://www.gnu.org/licenses/>.
      20             : */
      21             : 
      22             : #include "includes.h"
      23             : #include "lib/events/events.h"
      24             : #include <ldb.h>
      25             : #include <ldb_errors.h>
      26             : #include "lib/ldb-samba/ldif_handlers.h"
      27             : #include "ldb_wrap.h"
      28             : #include "dsdb/samdb/samdb.h"
      29             : #include "param/param.h"
      30             : #include "torture/smbtorture.h"
      31             : #include "torture/local/proto.h"
      32             : #include "param/provision.h"
      33             : 
      34             : 
      35             : struct torture_dsdb_syntax {
      36             :         struct ldb_context *ldb;
      37             :         struct dsdb_schema *schema;
      38             : };
      39             : 
      40          10 : DATA_BLOB hexstr_to_data_blob(TALLOC_CTX *mem_ctx, const char *string) 
      41             : {
      42          10 :         DATA_BLOB binary = data_blob_talloc(mem_ctx, NULL, strlen(string)/2);
      43          10 :         binary.length = strhex_to_str((char *)binary.data, binary.length, string, strlen(string));
      44          10 :         return binary;
      45             : }
      46             : 
      47           1 : static bool torture_syntax_add_OR_Name(struct torture_context *tctx,
      48             :                                        struct ldb_context *ldb,
      49             :                                        struct dsdb_schema *schema)
      50             : {
      51           1 :         WERROR werr;
      52           1 :         int ldb_res;
      53           1 :         struct ldb_ldif *ldif;
      54           1 :         const char *ldif_str =  "dn: CN=ms-Exch-Auth-Orig,CN=Schema,CN=Configuration,DC=kma-exch,DC=devel\n"
      55             :                                 "changetype: add\n"
      56             :                                 "cn: ms-Exch-Auth-Orig\n"
      57             :                                 "attributeID: 1.2.840.113556.1.2.129\n"
      58             :                                 "attributeSyntax: 2.5.5.7\n"
      59             :                                 "isSingleValued: FALSE\n"
      60             :                                 "linkID: 110\n"
      61             :                                 "showInAdvancedViewOnly: TRUE\n"
      62             :                                 "adminDisplayName: ms-Exch-Auth-Orig\n"
      63             :                                 "oMObjectClass:: VgYBAgULHQ==\n"
      64             :                                 "adminDescription: ms-Exch-Auth-Orig\n"
      65             :                                 "oMSyntax: 127\n"
      66             :                                 "searchFlags: 16\n"
      67             :                                 "lDAPDisplayName: authOrig\n"
      68             :                                 "name: ms-Exch-Auth-Orig\n"
      69             :                                 "objectGUID:: 7tqEWktjAUqsZXqsFPQpRg==\n"
      70             :                                 "schemaIDGUID:: l3PfqOrF0RG7ywCAx2ZwwA==\n"
      71             :                                 "attributeSecurityGUID:: VAGN5Pi80RGHAgDAT7lgUA==\n"
      72             :                                 "isMemberOfPartialAttributeSet: TRUE\n";
      73             : 
      74           1 :         ldif = ldb_ldif_read_string(ldb, &ldif_str);
      75           1 :         torture_assert(tctx, ldif, "Failed to parse LDIF for authOrig");
      76             : 
      77           1 :         werr = dsdb_set_attribute_from_ldb(ldb, schema, ldif->msg);
      78           1 :         ldb_ldif_read_free(ldb, ldif);
      79           1 :         torture_assert_werr_ok(tctx, werr, "dsdb_set_attribute_from_ldb() failed!");
      80             : 
      81           1 :         ldb_res = dsdb_set_schema(ldb, schema, SCHEMA_WRITE);
      82           1 :         torture_assert_int_equal(tctx, ldb_res, LDB_SUCCESS, "dsdb_set_schema() failed");
      83             : 
      84           0 :         return true;
      85             : };
      86             : 
      87          10 : static bool torture_test_syntax(struct torture_context *torture,
      88             :                                 struct torture_dsdb_syntax *priv,
      89             :                                 const char *oid,
      90             :                                 const char *attr_string,
      91             :                                 const char *ldb_str,
      92             :                                 const char *drs_str)
      93             : {
      94          10 :         TALLOC_CTX *tmp_ctx = talloc_new(torture);
      95          10 :         DATA_BLOB drs_binary = hexstr_to_data_blob(tmp_ctx, drs_str);
      96          10 :         DATA_BLOB ldb_blob = data_blob_string_const(ldb_str);
      97          10 :         struct drsuapi_DsReplicaAttribute drs, drs2;
      98          10 :         struct drsuapi_DsAttributeValue val;
      99          10 :         const struct dsdb_syntax *syntax;
     100          10 :         const struct dsdb_attribute *attr;
     101          10 :         struct ldb_message_element el;
     102          10 :         struct ldb_context *ldb = priv->ldb;
     103          10 :         struct dsdb_schema *schema = priv->schema;
     104          10 :         struct dsdb_syntax_ctx syntax_ctx;
     105             : 
     106             :         /* use default syntax conversion context */
     107          10 :         dsdb_syntax_ctx_init(&syntax_ctx, ldb, schema);
     108             : 
     109          10 :         drs.value_ctr.num_values = 1;
     110          10 :         drs.value_ctr.values = &val;
     111          10 :         val.blob = &drs_binary;
     112             : 
     113          10 :         torture_assert(torture, syntax = find_syntax_map_by_standard_oid(oid), "Failed to find syntax handler");
     114          10 :         torture_assert(torture, attr = dsdb_attribute_by_lDAPDisplayName(schema, attr_string), "Failed to find attribute handler");
     115          10 :         torture_assert_str_equal(torture, attr->syntax->name, syntax->name, "Syntax from schema not as expected");
     116             :         
     117             : 
     118          10 :         torture_assert_werr_ok(torture, syntax->drsuapi_to_ldb(&syntax_ctx, attr, &drs, tmp_ctx, &el), "Failed to convert from DRS to ldb format");
     119             : 
     120          10 :         torture_assert_data_blob_equal(torture, el.values[0], ldb_blob, "Incorrect conversion from DRS to ldb format");
     121             : 
     122          10 :         torture_assert_werr_ok(torture, syntax->validate_ldb(&syntax_ctx, attr, &el), "Failed to validate ldb format");
     123             : 
     124          10 :         torture_assert_werr_ok(torture, syntax->ldb_to_drsuapi(&syntax_ctx, attr, &el, tmp_ctx, &drs2), "Failed to convert from ldb to DRS format");
     125             :         
     126          10 :         torture_assert(torture, drs2.value_ctr.values[0].blob, "No blob returned from conversion");
     127             : 
     128          10 :         torture_assert_data_blob_equal(torture, *drs2.value_ctr.values[0].blob, drs_binary, "Incorrect conversion from ldb to DRS format");
     129           0 :         return true;
     130             : }
     131             : 
     132           1 : static bool torture_dsdb_drs_DN_BINARY(struct torture_context *torture, struct torture_dsdb_syntax *priv)
     133             : {
     134           1 :         bool ret;
     135           1 :         const char *ldb_str = "B:32:A9D1CA15768811D1ADED00C04FD8D5CD:<GUID=a8378c29-6319-45b3-b216-6a3108452d6c>;CN=Users,DC=ad,DC=ruth,DC=abartlet,DC=net";
     136           1 :         const char *drs_str = "8C00000000000000298C37A81963B345B2166A3108452D6C000000000000000000000000000000000000000000000000000000002900000043004E003D00550073006500720073002C00440043003D00610064002C00440043003D0072007500740068002C00440043003D00610062006100720074006C00650074002C00440043003D006E0065007400000014000000A9D1CA15768811D1ADED00C04FD8D5CD";
     137           1 :         const char *ldb_str2 = "B:8:00000002:<GUID=2b475208-3180-4ad4-b6bb-a26cfb44ac50>;<SID=S-1-5-21-3686369990-3108025515-1819299124>;DC=ad,DC=ruth,DC=abartlet,DC=net";
     138           1 :         const char *drs_str2 = "7A000000180000000852472B8031D44AB6BBA26CFB44AC50010400000000000515000000C68AB9DBABB440B9344D706C0000000020000000440043003D00610064002C00440043003D0072007500740068002C00440043003D00610062006100720074006C00650074002C00440043003D006E0065007400000000000800000000000002";
     139           1 :         ret = torture_test_syntax(torture, priv, DSDB_SYNTAX_BINARY_DN, "wellKnownObjects", ldb_str, drs_str);
     140           1 :         if (!ret) return false;
     141           1 :         return torture_test_syntax(torture, priv, DSDB_SYNTAX_BINARY_DN, "msDS-HasInstantiatedNCs", ldb_str2, drs_str2);
     142             : }
     143             : 
     144           1 : static bool torture_dsdb_drs_DN(struct torture_context *torture, struct torture_dsdb_syntax *priv)
     145             : {
     146           1 :         const char *ldb_str = "<GUID=fbee08fd-6f75-4bd4-af3f-e4f063a6379e>;OU=Domain Controllers,DC=ad,DC=naomi,DC=abartlet,DC=net";
     147           1 :         const char *drs_str = "A800000000000000FD08EEFB756FD44BAF3FE4F063A6379E00000000000000000000000000000000000000000000000000000000370000004F0055003D0044006F006D00610069006E00200043006F006E00740072006F006C006C006500720073002C00440043003D00610064002C00440043003D006E0061006F006D0069002C00440043003D00610062006100720074006C00650074002C00440043003D006E00650074000000";
     148           1 :         if (!torture_test_syntax(torture, priv, LDB_SYNTAX_DN, "lastKnownParent", ldb_str, drs_str)) {
     149           0 :                 return false;
     150             :         }
     151             : 
     152             :         /* extended_dn with GUID and SID in it */
     153           1 :         ldb_str = "<GUID=23cc7d16-3da0-4f3a-9921-0ad60a99230f>;<SID=S-1-5-21-3427639452-1671929926-2759570404-500>;CN=Administrator,CN=Users,DC=kma-exch,DC=devel";
     154           1 :         drs_str = "960000001C000000167DCC23A03D3A4F99210AD60A99230F0105000000000005150000009CA04DCC46A0A763E4B37BA4F40100002E00000043004E003D00410064006D0069006E006900730074007200610074006F0072002C0043004E003D00550073006500720073002C00440043003D006B006D0061002D0065007800630068002C00440043003D0064006500760065006C000000";
     155           1 :         return torture_test_syntax(torture, priv, LDB_SYNTAX_DN, "lastKnownParent", ldb_str, drs_str);
     156             : }
     157             : 
     158           1 : static bool torture_dsdb_drs_OR_Name(struct torture_context *torture, struct torture_dsdb_syntax *priv)
     159             : {
     160           1 :         const char *ldb_str = "<GUID=23cc7d16-3da0-4f3a-9921-0ad60a99230f>;<SID=S-1-5-21-3427639452-1671929926-2759570404-500>;CN=Administrator,CN=Users,DC=kma-exch,DC=devel";
     161           1 :         const char *drs_str = "960000001C000000167DCC23A03D3A4F99210AD60A99230F0105000000000005150000009CA04DCC46A0A763E4B37BA4F40100002E00000043004E003D00410064006D0069006E006900730074007200610074006F0072002C0043004E003D00550073006500720073002C00440043003D006B006D0061002D0065007800630068002C00440043003D0064006500760065006C000000000004000000";
     162           1 :         return torture_test_syntax(torture, priv, DSDB_SYNTAX_OR_NAME, "authOrig", ldb_str, drs_str);
     163             : }
     164             : 
     165           1 : static bool torture_dsdb_drs_INT32(struct torture_context *torture, struct torture_dsdb_syntax *priv)
     166             : {
     167           1 :         const char *ldb_str = "532480";
     168           1 :         const char *drs_str = "00200800";
     169           1 :         return torture_test_syntax(torture, priv, LDB_SYNTAX_INTEGER, "userAccountControl", ldb_str, drs_str);
     170             : }
     171             : 
     172           1 : static bool torture_dsdb_drs_INT64(struct torture_context *torture, struct torture_dsdb_syntax *priv)
     173             : {
     174           1 :         const char *ldb_str = "129022979538281250";
     175           1 :         const char *drs_str = "22E33D5FB761CA01";
     176           1 :         return torture_test_syntax(torture, priv, "1.2.840.113556.1.4.906", "pwdLastSet", ldb_str, drs_str);
     177             : }
     178             : 
     179           1 : static bool torture_dsdb_drs_NTTIME(struct torture_context *torture, struct torture_dsdb_syntax *priv)
     180             : {
     181           1 :         const char *ldb_str = "20091109003446.0Z";
     182           1 :         const char *drs_str = "A6F4070103000000";
     183           1 :         return torture_test_syntax(torture, priv, "1.3.6.1.4.1.1466.115.121.1.24", "whenCreated", ldb_str, drs_str);
     184             : }
     185             : 
     186           1 : static bool torture_dsdb_drs_BOOL(struct torture_context *torture, struct torture_dsdb_syntax *priv)
     187             : {
     188           1 :         const char *ldb_str = "TRUE";
     189           1 :         const char *drs_str = "01000000";
     190           1 :         return torture_test_syntax(torture, priv, LDB_SYNTAX_BOOLEAN, "isDeleted", ldb_str, drs_str);
     191             : }
     192             : 
     193           1 : static bool torture_dsdb_drs_UNICODE(struct torture_context *torture, struct torture_dsdb_syntax *priv)
     194             : {
     195           1 :         const char *ldb_str = "primaryTelexNumber,Numéro de télex";
     196           1 :         const char *drs_str = "7000720069006D00610072007900540065006C00650078004E0075006D006200650072002C004E0075006D00E90072006F0020006400650020007400E9006C0065007800";
     197           1 :         return torture_test_syntax(torture, priv, LDB_SYNTAX_DIRECTORY_STRING, "attributeDisplayNames", ldb_str, drs_str);
     198             : }
     199             : 
     200             : /*
     201             :  * DSDB-SYNTAX fixture setup/teardown handlers implementation
     202             :  */
     203           1 : static bool torture_dsdb_syntax_tcase_setup(struct torture_context *tctx, void **data)
     204             : {
     205           1 :         struct torture_dsdb_syntax *priv;
     206             : 
     207           1 :         priv = talloc_zero(tctx, struct torture_dsdb_syntax);
     208           1 :         torture_assert(tctx, priv, "No memory");
     209             : 
     210           1 :         priv->ldb = provision_get_schema(priv, tctx->lp_ctx, NULL, NULL);
     211           1 :         torture_assert(tctx, priv->ldb, "Failed to load schema from disk");
     212             : 
     213           1 :         priv->schema = dsdb_get_schema(priv->ldb, NULL);
     214           1 :         torture_assert(tctx, priv->schema, "Failed to fetch schema");
     215             : 
     216             :         /* add 'authOrig' attribute with OR-Name syntax to schema */
     217           1 :         if (!torture_syntax_add_OR_Name(tctx, priv->ldb, priv->schema)) {
     218           0 :                 return false;
     219             :         }
     220             : 
     221           1 :         *data = priv;
     222           1 :         return true;
     223             : }
     224             : 
     225           1 : static bool torture_dsdb_syntax_tcase_teardown(struct torture_context *tctx, void *data)
     226             : {
     227           1 :         struct torture_dsdb_syntax *priv;
     228             : 
     229           1 :         priv = talloc_get_type_abort(data, struct torture_dsdb_syntax);
     230           1 :         talloc_unlink(priv, priv->ldb);
     231           1 :         talloc_free(priv);
     232             : 
     233           1 :         return true;
     234             : }
     235             : 
     236             : /**
     237             :  * DSDB-SYNTAX test suite creation
     238             :  */
     239        2363 : struct torture_suite *torture_dsdb_syntax(TALLOC_CTX *mem_ctx)
     240             : {
     241         125 :         typedef bool (*pfn_run)(struct torture_context *, void *);
     242             : 
     243         125 :         struct torture_tcase *tc;
     244        2363 :         struct torture_suite *suite = torture_suite_create(mem_ctx, "dsdb.syntax");
     245             : 
     246        2363 :         if (suite == NULL) {
     247           0 :                 return NULL;
     248             :         }
     249             : 
     250        2363 :         tc = torture_suite_add_tcase(suite, "tc");
     251        2363 :         if (!tc) {
     252           0 :                 return NULL;
     253             :         }
     254             : 
     255        2363 :         torture_tcase_set_fixture(tc,
     256             :                                   torture_dsdb_syntax_tcase_setup,
     257             :                                   torture_dsdb_syntax_tcase_teardown);
     258             : 
     259        2363 :         torture_tcase_add_simple_test(tc, "DN-BINARY", (pfn_run)torture_dsdb_drs_DN_BINARY);
     260        2363 :         torture_tcase_add_simple_test(tc, "DN", (pfn_run)torture_dsdb_drs_DN);
     261        2363 :         torture_tcase_add_simple_test(tc, "OR-Name", (pfn_run)torture_dsdb_drs_OR_Name);
     262        2363 :         torture_tcase_add_simple_test(tc, "INT32", (pfn_run)torture_dsdb_drs_INT32);
     263        2363 :         torture_tcase_add_simple_test(tc, "INT64", (pfn_run)torture_dsdb_drs_INT64);
     264        2363 :         torture_tcase_add_simple_test(tc, "NTTIME", (pfn_run)torture_dsdb_drs_NTTIME);
     265        2363 :         torture_tcase_add_simple_test(tc, "BOOL", (pfn_run)torture_dsdb_drs_BOOL);
     266        2363 :         torture_tcase_add_simple_test(tc, "UNICODE", (pfn_run)torture_dsdb_drs_UNICODE);
     267             : 
     268        2363 :         suite->description = talloc_strdup(suite, "DSDB syntax tests");
     269             : 
     270        2363 :         return suite;
     271             : }

Generated by: LCOV version 1.14