source3/libgpo/gpext/registry.c

   1 /*
   2  *  Unix SMB/CIFS implementation.
   3  *  Group Policy Support
   4  *  Copyright (C) Guenther Deschner 2007-2008,2010
   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 "includes.h"
  21 #include "../libgpo/gpo_ini.h"
  22 #include "../libgpo/gpo.h"
  23 #include "libgpo/gpo_proto.h"
  24 #include "registry.h"
  25 #include "../librpc/gen_ndr/ndr_preg.h"
  26 #include "libgpo/gpext/gpext.h"
  27
  28 #define GP_EXT_NAME "registry"
  29
  30 /* more info can be found at:
  31  * http://msdn2.microsoft.com/en-us/library/aa374407.aspx */
  32
  33 #define GP_REGPOL_FILE  "Registry.pol"
  34
  35 #define GP_REGPOL_FILE_SIGNATURE 0x67655250 /* 'PReg' */
  36 #define GP_REGPOL_FILE_VERSION 1
  37
  38 static TALLOC_CTX *ctx = NULL;
  39
  40 /****************************************************************
  41 ****************************************************************/
  42
  43 static bool reg_parse_value(TALLOC_CTX *mem_ctx,
  44                             const char **value,
  45                             enum gp_reg_action *action)
  46 {
  47         if (!*value) {
  48                 *action = GP_REG_ACTION_ADD_KEY;
  49                 return true;
  50         }
  51
  52         if (strncmp(*value, "**", 2) != 0) {
  53                 *action = GP_REG_ACTION_ADD_VALUE;
  54                 return true;
  55         }
  56
  57         if (strnequal(*value, "**DelVals.", 10)) {
  58                 *action = GP_REG_ACTION_DEL_ALL_VALUES;
  59                 return true;
  60         }
  61
  62         if (strnequal(*value, "**Del.", 6)) {
  63                 *value = talloc_strdup(mem_ctx, *value + 6);
  64                 *action = GP_REG_ACTION_DEL_VALUE;
  65                 return true;
  66         }
  67
  68         if (strnequal(*value, "**SecureKey", 11)) {
  69                 if (strnequal(*value, "**SecureKey=1", 13)) {
  70                         *action = GP_REG_ACTION_SEC_KEY_SET;
  71                         return true;
  72                 }
  73
  74  /*************** not tested from here on ***************/
  75                 if (strnequal(*value, "**SecureKey=0", 13)) {
  76                         smb_panic("not supported: **SecureKey=0");
  77                         *action = GP_REG_ACTION_SEC_KEY_RESET;
  78                         return true;
  79                 }
  80                 DEBUG(0,("unknown: SecureKey: %s\n", *value));
  81                 smb_panic("not supported SecureKey method");
  82                 return false;
  83         }
  84
  85         if (strnequal(*value, "**DeleteValues", strlen("**DeleteValues"))) {
  86                 smb_panic("not supported: **DeleteValues");
  87                 *action = GP_REG_ACTION_DEL_VALUES;
  88                 return false;
  89         }
  90
  91         if (strnequal(*value, "**DeleteKeys", strlen("**DeleteKeys"))) {
  92                 smb_panic("not supported: **DeleteKeys");
  93                 *action = GP_REG_ACTION_DEL_KEYS;
  94                 return false;
  95         }
  96
  97         DEBUG(0,("unknown value: %s\n", *value));
  98         smb_panic(*value);
  99         return false;
 100 }
 101
 102 /****************************************************************
 103 ****************************************************************/
 104
 105 static bool gp_reg_entry_from_file_entry(TALLOC_CTX *mem_ctx,
 106                                          struct preg_entry *r,
 107                                          struct gp_registry_entry **reg_entry)
 108 {
 109         struct registry_value *data = NULL;
 110         struct gp_registry_entry *entry = NULL;
 111         enum gp_reg_action action = GP_REG_ACTION_NONE;
 112
 113         ZERO_STRUCTP(*reg_entry);
 114
 115         data = talloc_zero(mem_ctx, struct registry_value);
 116         if (!data)
 117                 return false;
 118
 119         data->type = r->type;
 120         data->data = data_blob_talloc(data, r->data, r->size);
 121
 122         entry = talloc_zero(mem_ctx, struct gp_registry_entry);
 123         if (!entry)
 124                 return false;
 125
 126         if (!reg_parse_value(mem_ctx, &r->valuename, &action))
 127                 return false;
 128
 129         entry->key = talloc_strdup(entry, r->keyname);
 130         entry->value = talloc_strdup(entry, r->valuename);
 131         entry->data = data;
 132         entry->action = action;
 133
 134         *reg_entry = entry;
 135
 136         return true;
 137 }
 138
 139 /****************************************************************
 140 ****************************************************************/
 141
 142 static NTSTATUS reg_parse_registry(TALLOC_CTX *mem_ctx,
 143                                    uint32_t flags,
 144                                    const char *filename,
 145                                    struct gp_registry_entry **entries_p,
 146                                    size_t *num_entries_p)
 147 {
 148         DATA_BLOB blob;
 149         NTSTATUS status;
 150         enum ndr_err_code ndr_err;
 151         const char *real_filename = NULL;
 152         struct preg_file r;
 153         struct gp_registry_entry *entries = NULL;
 154         size_t num_entries = 0;
 155         int i;
 156
 157         status = gp_find_file(mem_ctx,
 158                               flags,
 159                               filename,
 160                               GP_REGPOL_FILE,
 161                               &real_filename);
 162         if (!NT_STATUS_IS_OK(status)) {
 163                 return status;
 164         }
 165
 166         blob.data = (uint8_t *)file_load(real_filename, &blob.length, 0, NULL);
 167         if (!blob.data) {
 168                 return NT_STATUS_CANNOT_LOAD_REGISTRY_FILE;
 169         }
 170
 171         ndr_err = ndr_pull_struct_blob(&blob, mem_ctx, &r,
 172                         (ndr_pull_flags_fn_t)ndr_pull_preg_file);
 173         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 174                 status = ndr_map_error2ntstatus(ndr_err);
 175                 goto out;
 176         }
 177
 178         if (flags & GPO_INFO_FLAG_VERBOSE) {
 179                 NDR_PRINT_DEBUG(preg_file, &r);
 180         }
 181
 182         if (!strequal(r.header.signature, "PReg")) {
 183                 status = NT_STATUS_INVALID_PARAMETER;
 184                 goto out;
 185         }
 186
 187         if (r.header.version != GP_REGPOL_FILE_VERSION) {
 188                 status = NT_STATUS_INVALID_PARAMETER;
 189                 goto out;
 190         }
 191
 192         for (i=0; i < r.num_entries; i++) {
 193
 194                 struct gp_registry_entry *r_entry = NULL;
 195
 196                 if (!gp_reg_entry_from_file_entry(mem_ctx,
 197                                                   &r.entries[i],
 198                                                   &r_entry)) {
 199                         status = NT_STATUS_NO_MEMORY;
 200                         goto out;
 201                 }
 202
 203                 if (!add_gp_registry_entry_to_array(mem_ctx,
 204                                                     r_entry,
 205                                                     &entries,
 206                                                     &num_entries)) {
 207                         status = NT_STATUS_NO_MEMORY;
 208                         goto out;
 209                 }
 210         }
 211
 212         *entries_p = entries;
 213         *num_entries_p = num_entries;
 214
 215         status = NT_STATUS_OK;
 216
 217  out:
 218         data_blob_free(&blob);
 219         return status;
 220 }
 221
 222 /****************************************************************
 223 ****************************************************************/
 224
 225 static WERROR reg_apply_registry(TALLOC_CTX *mem_ctx,
 226                                  const struct security_token *token,
 227                                  struct registry_key *root_key,
 228                                  uint32_t flags,
 229                                  struct gp_registry_entry *entries,
 230                                  size_t num_entries)
 231 {
 232         struct gp_registry_context *reg_ctx = NULL;
 233         WERROR werr;
 234         size_t i;
 235
 236         if (num_entries == 0) {
 237                 return WERR_OK;
 238         }
 239
 240 #if 0
 241         if (flags & GPO_LIST_FLAG_MACHINE) {
 242                 werr = gp_init_reg_ctx(mem_ctx, KEY_HKLM, REG_KEY_WRITE,
 243                                        get_system_token(),
 244                                        &reg_ctx);
 245         } else {
 246                 werr = gp_init_reg_ctx(mem_ctx, KEY_HKCU, REG_KEY_WRITE,
 247                                        token,
 248                                        &reg_ctx);
 249         }
 250         W_ERROR_NOT_OK_RETURN(werr);
 251 #endif
 252         for (i=0; i<num_entries; i++) {
 253
 254                 /* FIXME: maybe we should check here if we attempt to go beyond
 255                  * the 4 allowed reg keys */
 256
 257                 werr = reg_apply_registry_entry(mem_ctx, root_key,
 258                                                 reg_ctx,
 259                                                 &(entries)[i],
 260                                                 token, flags);
 261                 if (!W_ERROR_IS_OK(werr)) {
 262                         DEBUG(0,("failed to apply registry: %s\n",
 263                                 win_errstr(werr)));
 264                         goto done;
 265                 }
 266         }
 267
 268 done:
 269         gp_free_reg_ctx(reg_ctx);
 270         return werr;
 271 }
 272
 273
 274 /****************************************************************
 275 ****************************************************************/
 276
 277 static NTSTATUS registry_process_group_policy(TALLOC_CTX *mem_ctx,
 278                                               uint32_t flags,
 279                                               struct registry_key *root_key,
 280                                               const struct security_token *token,
 281                                               const struct GROUP_POLICY_OBJECT *deleted_gpo_list,
 282                                               const struct GROUP_POLICY_OBJECT *changed_gpo_list)
 283 {
 284         NTSTATUS status;
 285         WERROR werr;
 286         struct gp_registry_entry *entries = NULL;
 287         size_t num_entries = 0;
 288         char *unix_path = NULL;
 289         const struct GROUP_POLICY_OBJECT *gpo;
 290
 291         /* implementation of the policy callback function, see
 292          * http://msdn.microsoft.com/en-us/library/aa373494%28v=vs.85%29.aspx
 293          * for details - gd */
 294
 295         /* for now do not process the list of deleted group policies
 296
 297         for (gpo = deleted_gpo_list; gpo; gpo = gpo->next) {
 298         }
 299
 300         */
 301
 302         for (gpo = changed_gpo_list; gpo; gpo = gpo->next) {
 303
 304                 gpext_debug_header(0, "registry_process_group_policy", flags,
 305                                    gpo, GP_EXT_GUID_REGISTRY, NULL);
 306
 307                 status = gpo_get_unix_path(mem_ctx, cache_path(GPO_CACHE_DIR),
 308                                            gpo, &unix_path);
 309                 NT_STATUS_NOT_OK_RETURN(status);
 310
 311                 status = reg_parse_registry(mem_ctx,
 312                                             flags,
 313                                             unix_path,
 314                                             &entries,
 315                                             &num_entries);
 316                 if (!NT_STATUS_IS_OK(status)) {
 317                         DEBUG(0,("failed to parse registry: %s\n",
 318                                 nt_errstr(status)));
 319                         return status;
 320                 }
 321
 322                 dump_reg_entries(flags, "READ", entries, num_entries);
 323
 324                 werr = reg_apply_registry(mem_ctx, token, root_key, flags,
 325                                           entries, num_entries);
 326                 if (!W_ERROR_IS_OK(werr)) {
 327                         DEBUG(0,("failed to apply registry: %s\n",
 328                                 win_errstr(werr)));
 329                         return werror_to_ntstatus(werr);
 330                 }
 331         }
 332
 333         return NT_STATUS_OK;
 334 }
 335
 336 /****************************************************************
 337 ****************************************************************/
 338
 339 static NTSTATUS registry_get_reg_config(TALLOC_CTX *mem_ctx,
 340                                         struct gp_extension_reg_info **reg_info)
 341 {
 342         NTSTATUS status;
 343         struct gp_extension_reg_info *info = NULL;
 344         struct gp_extension_reg_table table[] = {
 345                 { "ProcessGroupPolicy", REG_SZ, "registry_process_group_policy" },
 346                 { NULL, REG_NONE, NULL }
 347         };
 348
 349         info = talloc_zero(mem_ctx, struct gp_extension_reg_info);
 350         NT_STATUS_HAVE_NO_MEMORY(info);
 351
 352         status = gpext_info_add_entry(mem_ctx, GP_EXT_NAME,
 353                                       GP_EXT_GUID_REGISTRY,
 354                                       table, info);
 355         NT_STATUS_NOT_OK_RETURN(status);
 356
 357         *reg_info = info;
 358
 359         return NT_STATUS_OK;
 360 }
 361
 362 /****************************************************************
 363 ****************************************************************/
 364
 365 static NTSTATUS registry_initialize(TALLOC_CTX *mem_ctx)
 366 {
 367         return NT_STATUS_OK;
 368 }
 369
 370 /****************************************************************
 371 ****************************************************************/
 372
 373 static NTSTATUS registry_shutdown(void)
 374 {
 375         NTSTATUS status;
 376
 377         status = gpext_unregister_gp_extension(GP_EXT_NAME);
 378         if (NT_STATUS_IS_OK(status)) {
 379                 return status;
 380         }
 381
 382         TALLOC_FREE(ctx);
 383
 384         return NT_STATUS_OK;
 385 }
 386
 387 /****************************************************************
 388 ****************************************************************/
 389
 390 static struct gp_extension_methods registry_methods = {
 391         .initialize             = registry_initialize,
 392         .process_group_policy   = registry_process_group_policy,
 393         .get_reg_config         = registry_get_reg_config,
 394         .shutdown               = registry_shutdown
 395 };
 396
 397 /****************************************************************
 398 ****************************************************************/
 399
 400 NTSTATUS gpext_registry_init(void)
 401 {
 402         NTSTATUS status;
 403
 404         ctx = talloc_init("gpext_registry_init");
 405         NT_STATUS_HAVE_NO_MEMORY(ctx);
 406
 407         status = gpext_register_gp_extension(ctx, SMB_GPEXT_INTERFACE_VERSION,
 408                                              GP_EXT_NAME, GP_EXT_GUID_REGISTRY,
 409                                              &registry_methods);
 410         if (!NT_STATUS_IS_OK(status)) {
 411                 TALLOC_FREE(ctx);
 412         }
 413
 414         return status;
 415 }