[ADVAPI32][SERVICES] Add (dummy) password encryption/decryption functions to CreateSe...
[reactos.git] / base / system / services / config.c
1 /*
2 * PROJECT: ReactOS Service Control Manager
3 * LICENSE: GPL - See COPYING in the top level directory
4 * FILE: base/system/services/config.c
5 * PURPOSE: Service configuration interface
6 * COPYRIGHT: Copyright 2005 Eric Kohl
7 *
8 */
9
10 /* INCLUDES *****************************************************************/
11
12 #include "services.h"
13 #include <ntsecapi.h>
14
15 #define NDEBUG
16 #include <debug.h>
17
18
19 /* FUNCTIONS *****************************************************************/
20
21
22 DWORD
23 ScmOpenServiceKey(LPWSTR lpServiceName,
24 REGSAM samDesired,
25 PHKEY phKey)
26 {
27 HKEY hServicesKey = NULL;
28 DWORD dwError;
29
30 *phKey = NULL;
31
32 dwError = RegOpenKeyExW(HKEY_LOCAL_MACHINE,
33 L"System\\CurrentControlSet\\Services",
34 0,
35 KEY_READ,
36 &hServicesKey);
37 if (dwError != ERROR_SUCCESS)
38 return dwError;
39
40 dwError = RegOpenKeyExW(hServicesKey,
41 lpServiceName,
42 0,
43 samDesired,
44 phKey);
45
46 RegCloseKey(hServicesKey);
47
48 return dwError;
49 }
50
51
52 DWORD
53 ScmCreateServiceKey(LPCWSTR lpServiceName,
54 REGSAM samDesired,
55 PHKEY phKey)
56 {
57 HKEY hServicesKey = NULL;
58 DWORD dwDisposition;
59 DWORD dwError;
60
61 *phKey = NULL;
62
63 dwError = RegOpenKeyExW(HKEY_LOCAL_MACHINE,
64 L"System\\CurrentControlSet\\Services",
65 0,
66 KEY_READ | KEY_CREATE_SUB_KEY,
67 &hServicesKey);
68 if (dwError != ERROR_SUCCESS)
69 return dwError;
70
71 dwError = RegCreateKeyExW(hServicesKey,
72 lpServiceName,
73 0,
74 NULL,
75 REG_OPTION_NON_VOLATILE,
76 samDesired,
77 NULL,
78 phKey,
79 &dwDisposition);
80 #if 0
81 if ((dwError == ERROR_SUCCESS) &&
82 (dwDisposition == REG_OPENED_EXISTING_KEY))
83 {
84 RegCloseKey(*phKey);
85 *phKey = NULL;
86 dwError = ERROR_SERVICE_EXISTS;
87 }
88 #endif
89
90 RegCloseKey(hServicesKey);
91
92 return dwError;
93 }
94
95
96
97 DWORD
98 ScmWriteDependencies(HKEY hServiceKey,
99 LPCWSTR lpDependencies,
100 DWORD dwDependenciesLength)
101 {
102 DWORD dwError = ERROR_SUCCESS;
103 SIZE_T cchGroupLength = 0;
104 SIZE_T cchServiceLength = 0;
105 SIZE_T cchLength;
106 LPWSTR lpGroupDeps;
107 LPWSTR lpServiceDeps;
108 LPCWSTR lpSrc;
109 LPWSTR lpDst;
110
111 if (*lpDependencies == 0)
112 {
113 RegDeleteValueW(hServiceKey,
114 L"DependOnService");
115 RegDeleteValueW(hServiceKey,
116 L"DependOnGroup");
117 }
118 else
119 {
120 lpGroupDeps = HeapAlloc(GetProcessHeap(),
121 HEAP_ZERO_MEMORY,
122 (dwDependenciesLength + 2) * sizeof(WCHAR));
123 if (lpGroupDeps == NULL)
124 return ERROR_NOT_ENOUGH_MEMORY;
125
126 lpSrc = lpDependencies;
127 lpDst = lpGroupDeps;
128 while (*lpSrc != 0)
129 {
130 cchLength = wcslen(lpSrc) + 1;
131 if (*lpSrc == SC_GROUP_IDENTIFIERW)
132 {
133 lpSrc++;
134 cchLength--;
135 cchGroupLength += cchLength;
136 wcscpy(lpDst, lpSrc);
137 lpDst = lpDst + cchLength;
138 }
139
140 lpSrc = lpSrc + cchLength;
141 }
142 *lpDst = 0;
143 lpDst++;
144 cchGroupLength++;
145
146 lpSrc = lpDependencies;
147 lpServiceDeps = lpDst;
148 while (*lpSrc != 0)
149 {
150 cchLength = wcslen(lpSrc) + 1;
151 if (*lpSrc != SC_GROUP_IDENTIFIERW)
152 {
153 cchServiceLength += cchLength;
154 wcscpy(lpDst, lpSrc);
155 lpDst = lpDst + cchLength;
156 }
157
158 lpSrc = lpSrc + cchLength;
159 }
160 *lpDst = 0;
161 cchServiceLength++;
162
163 if (cchGroupLength > 1)
164 {
165 dwError = RegSetValueExW(hServiceKey,
166 L"DependOnGroup",
167 0,
168 REG_MULTI_SZ,
169 (LPBYTE)lpGroupDeps,
170 (DWORD)(cchGroupLength * sizeof(WCHAR)));
171 }
172 else
173 {
174 RegDeleteValueW(hServiceKey,
175 L"DependOnGroup");
176 }
177
178 if (dwError == ERROR_SUCCESS)
179 {
180 if (cchServiceLength > 1)
181 {
182 dwError = RegSetValueExW(hServiceKey,
183 L"DependOnService",
184 0,
185 REG_MULTI_SZ,
186 (LPBYTE)lpServiceDeps,
187 (DWORD)(cchServiceLength * sizeof(WCHAR)));
188 }
189 else
190 {
191 RegDeleteValueW(hServiceKey,
192 L"DependOnService");
193 }
194 }
195
196 HeapFree(GetProcessHeap(), 0, lpGroupDeps);
197 }
198
199 return dwError;
200 }
201
202
203 DWORD
204 ScmMarkServiceForDelete(PSERVICE pService)
205 {
206 HKEY hServiceKey = NULL;
207 DWORD dwValue = 1;
208 DWORD dwError;
209
210 DPRINT("ScmMarkServiceForDelete() called\n");
211
212 dwError = ScmOpenServiceKey(pService->lpServiceName,
213 KEY_WRITE,
214 &hServiceKey);
215 if (dwError != ERROR_SUCCESS)
216 return dwError;
217
218 dwError = RegSetValueExW(hServiceKey,
219 L"DeleteFlag",
220 0,
221 REG_DWORD,
222 (LPBYTE)&dwValue,
223 sizeof(DWORD));
224
225 RegCloseKey(hServiceKey);
226
227 return dwError;
228 }
229
230
231 BOOL
232 ScmIsDeleteFlagSet(HKEY hServiceKey)
233 {
234 DWORD dwError;
235 DWORD dwType;
236 DWORD dwFlag;
237 DWORD dwSize = sizeof(DWORD);
238
239 dwError = RegQueryValueExW(hServiceKey,
240 L"DeleteFlag",
241 0,
242 &dwType,
243 (LPBYTE)&dwFlag,
244 &dwSize);
245
246 return (dwError == ERROR_SUCCESS);
247 }
248
249
250 DWORD
251 ScmReadString(HKEY hServiceKey,
252 LPCWSTR lpValueName,
253 LPWSTR *lpValue)
254 {
255 DWORD dwError = 0;
256 DWORD dwSize = 0;
257 DWORD dwType = 0;
258 LPWSTR ptr = NULL;
259 LPWSTR expanded = NULL;
260
261 *lpValue = NULL;
262
263 dwError = RegQueryValueExW(hServiceKey,
264 lpValueName,
265 0,
266 &dwType,
267 NULL,
268 &dwSize);
269 if (dwError != ERROR_SUCCESS)
270 return dwError;
271
272 ptr = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, dwSize);
273 if (ptr == NULL)
274 return ERROR_NOT_ENOUGH_MEMORY;
275
276 dwError = RegQueryValueExW(hServiceKey,
277 lpValueName,
278 0,
279 &dwType,
280 (LPBYTE)ptr,
281 &dwSize);
282 if (dwError != ERROR_SUCCESS)
283 {
284 HeapFree(GetProcessHeap(), 0, ptr);
285 return dwError;
286 }
287
288 if (dwType == REG_EXPAND_SZ)
289 {
290 /* Expand the value... */
291 dwSize = ExpandEnvironmentStringsW(ptr, NULL, 0);
292 if (dwSize > 0)
293 {
294 expanded = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, dwSize * sizeof(WCHAR));
295 if (expanded)
296 {
297 if (dwSize == ExpandEnvironmentStringsW(ptr, expanded, dwSize))
298 {
299 *lpValue = expanded;
300 dwError = ERROR_SUCCESS;
301 }
302 else
303 {
304 dwError = GetLastError();
305 HeapFree(GetProcessHeap(), 0, expanded);
306 }
307 }
308 else
309 {
310 dwError = ERROR_NOT_ENOUGH_MEMORY;
311 }
312 }
313 else
314 {
315 dwError = GetLastError();
316 }
317
318 HeapFree(GetProcessHeap(), 0, ptr);
319 }
320 else
321 {
322 *lpValue = ptr;
323 }
324
325 return dwError;
326 }
327
328
329 DWORD
330 ScmReadDependencies(HKEY hServiceKey,
331 LPWSTR *lpDependencies,
332 DWORD *lpdwDependenciesLength)
333 {
334 LPWSTR lpGroups = NULL;
335 LPWSTR lpServices = NULL;
336 SIZE_T cchGroupsLength = 0;
337 SIZE_T cchServicesLength = 0;
338 LPWSTR lpSrc;
339 LPWSTR lpDest;
340 SIZE_T cchLength;
341 SIZE_T cchTotalLength;
342
343 *lpDependencies = NULL;
344 *lpdwDependenciesLength = 0;
345
346 /* Read the dependency values */
347 ScmReadString(hServiceKey,
348 L"DependOnGroup",
349 &lpGroups);
350
351 ScmReadString(hServiceKey,
352 L"DependOnService",
353 &lpServices);
354
355 /* Leave, if there are no dependencies */
356 if (lpGroups == NULL && lpServices == NULL)
357 return ERROR_SUCCESS;
358
359 /* Determine the total buffer size for the dependencies */
360 if (lpGroups)
361 {
362 DPRINT("Groups:\n");
363 lpSrc = lpGroups;
364 while (*lpSrc != 0)
365 {
366 DPRINT(" %S\n", lpSrc);
367
368 cchLength = wcslen(lpSrc) + 1;
369 cchGroupsLength += cchLength + 1;
370
371 lpSrc = lpSrc + cchLength;
372 }
373 }
374
375 if (lpServices)
376 {
377 DPRINT("Services:\n");
378 lpSrc = lpServices;
379 while (*lpSrc != 0)
380 {
381 DPRINT(" %S\n", lpSrc);
382
383 cchLength = wcslen(lpSrc) + 1;
384 cchServicesLength += cchLength;
385
386 lpSrc = lpSrc + cchLength;
387 }
388 }
389
390 cchTotalLength = cchGroupsLength + cchServicesLength + 1;
391 DPRINT("cchTotalLength: %lu\n", cchTotalLength);
392
393 /* Allocate the common buffer for the dependencies */
394 *lpDependencies = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, cchTotalLength * sizeof(WCHAR));
395 if (*lpDependencies == NULL)
396 {
397 if (lpGroups)
398 HeapFree(GetProcessHeap(), 0, lpGroups);
399
400 if (lpServices)
401 HeapFree(GetProcessHeap(), 0, lpServices);
402
403 return ERROR_NOT_ENOUGH_MEMORY;
404 }
405
406 /* Return the allocated buffer length in characters */
407 *lpdwDependenciesLength = (DWORD)cchTotalLength;
408
409 /* Copy the service dependencies into the common buffer */
410 lpDest = *lpDependencies;
411 if (lpServices)
412 {
413 memcpy(lpDest,
414 lpServices,
415 cchServicesLength * sizeof(WCHAR));
416
417 lpDest = lpDest + cchServicesLength;
418 }
419
420 /* Copy the group dependencies into the common buffer */
421 if (lpGroups)
422 {
423 lpSrc = lpGroups;
424 while (*lpSrc != 0)
425 {
426 cchLength = wcslen(lpSrc) + 1;
427
428 *lpDest = SC_GROUP_IDENTIFIERW;
429 lpDest++;
430
431 wcscpy(lpDest, lpSrc);
432
433 lpDest = lpDest + cchLength;
434 lpSrc = lpSrc + cchLength;
435 }
436 }
437
438 /* Free the temporary buffers */
439 if (lpGroups)
440 HeapFree(GetProcessHeap(), 0, lpGroups);
441
442 if (lpServices)
443 HeapFree(GetProcessHeap(), 0, lpServices);
444
445 return ERROR_SUCCESS;
446 }
447
448
449 DWORD
450 ScmSetServicePassword(
451 IN PCWSTR pszServiceName,
452 IN PCWSTR pszPassword)
453 {
454 OBJECT_ATTRIBUTES ObjectAttributes;
455 LSA_HANDLE PolicyHandle = NULL;
456 UNICODE_STRING ServiceName = {0, 0, NULL};
457 UNICODE_STRING Password;
458 NTSTATUS Status;
459 DWORD dwError = ERROR_SUCCESS;
460
461 RtlZeroMemory(&ObjectAttributes, sizeof(OBJECT_ATTRIBUTES));
462
463 Status = LsaOpenPolicy(NULL,
464 &ObjectAttributes,
465 POLICY_CREATE_SECRET,
466 &PolicyHandle);
467 if (!NT_SUCCESS(Status))
468 return RtlNtStatusToDosError(Status);
469
470 ServiceName.Length = (wcslen(pszServiceName) + 4) * sizeof(WCHAR);
471 ServiceName.MaximumLength = ServiceName.Length + sizeof(WCHAR);
472 ServiceName.Buffer = HeapAlloc(GetProcessHeap(),
473 HEAP_ZERO_MEMORY,
474 ServiceName.MaximumLength);
475 if (ServiceName.Buffer == NULL)
476 return ERROR_NOT_ENOUGH_MEMORY;
477
478 wcscpy(ServiceName.Buffer, L"_SC_");
479 wcscat(ServiceName.Buffer, pszServiceName);
480
481 RtlInitUnicodeString(&Password, pszPassword);
482
483 Status = LsaStorePrivateData(PolicyHandle,
484 &ServiceName,
485 pszPassword ? &Password : NULL);
486 if (!NT_SUCCESS(Status))
487 {
488 dwError = RtlNtStatusToDosError(Status);
489 goto done;
490 }
491
492 done:
493 if (ServiceName.Buffer != NULL)
494 HeapFree(GetProcessHeap(), 0, ServiceName.Buffer);
495
496 if (PolicyHandle != NULL)
497 LsaClose(PolicyHandle);
498
499 return dwError;
500 }
501
502
503 DWORD
504 ScmWriteSecurityDescriptor(
505 _In_ HKEY hServiceKey,
506 _In_ PSECURITY_DESCRIPTOR pSecurityDescriptor)
507 {
508 HKEY hSecurityKey = NULL;
509 DWORD dwDisposition;
510 DWORD dwError;
511
512 DPRINT("ScmWriteSecurityDescriptor(%p %p)\n", hServiceKey, pSecurityDescriptor);
513
514 dwError = RegCreateKeyExW(hServiceKey,
515 L"Security",
516 0,
517 NULL,
518 REG_OPTION_NON_VOLATILE,
519 KEY_SET_VALUE,
520 NULL,
521 &hSecurityKey,
522 &dwDisposition);
523 if (dwError != ERROR_SUCCESS)
524 return dwError;
525
526 dwError = RegSetValueExW(hSecurityKey,
527 L"Security",
528 0,
529 REG_BINARY,
530 (LPBYTE)pSecurityDescriptor,
531 RtlLengthSecurityDescriptor(pSecurityDescriptor));
532
533 RegCloseKey(hSecurityKey);
534
535 return dwError;
536 }
537
538
539 DWORD
540 ScmReadSecurityDescriptor(
541 _In_ HKEY hServiceKey,
542 _Out_ PSECURITY_DESCRIPTOR *ppSecurityDescriptor)
543 {
544 PSECURITY_DESCRIPTOR pRelativeSD = NULL;
545 HKEY hSecurityKey = NULL;
546 DWORD dwBufferLength = 0;
547 DWORD dwType;
548 DWORD dwError;
549
550 DPRINT("ScmReadSecurityDescriptor(%p %p)\n", hServiceKey, ppSecurityDescriptor);
551
552 *ppSecurityDescriptor = NULL;
553
554 dwError = RegOpenKeyExW(hServiceKey,
555 L"Security",
556 0,
557 KEY_QUERY_VALUE,
558 &hSecurityKey);
559 if (dwError != ERROR_SUCCESS)
560 {
561 DPRINT("RegOpenKeyExW() failed (Error %lu)\n", dwError);
562
563 /* Do not fail if the Security key does not exist */
564 if (dwError == ERROR_FILE_NOT_FOUND)
565 dwError = ERROR_SUCCESS;
566 goto done;
567 }
568
569 dwError = RegQueryValueExW(hSecurityKey,
570 L"Security",
571 0,
572 &dwType,
573 NULL,
574 &dwBufferLength);
575 if (dwError != ERROR_SUCCESS)
576 {
577 DPRINT("RegQueryValueExW() failed (Error %lu)\n", dwError);
578
579 /* Do not fail if the Security value does not exist */
580 if (dwError == ERROR_FILE_NOT_FOUND)
581 dwError = ERROR_SUCCESS;
582 goto done;
583 }
584
585 DPRINT("dwBufferLength: %lu\n", dwBufferLength);
586 pRelativeSD = RtlAllocateHeap(RtlGetProcessHeap(),
587 HEAP_ZERO_MEMORY,
588 dwBufferLength);
589 if (pRelativeSD == NULL)
590 {
591 return ERROR_OUTOFMEMORY;
592 }
593
594 DPRINT("pRelativeSD: %lu\n", pRelativeSD);
595 dwError = RegQueryValueExW(hSecurityKey,
596 L"Security",
597 0,
598 &dwType,
599 (LPBYTE)pRelativeSD,
600 &dwBufferLength);
601 if (dwError != ERROR_SUCCESS)
602 {
603 goto done;
604 }
605
606 *ppSecurityDescriptor = pRelativeSD;
607
608 done:
609 if (dwError != ERROR_SUCCESS && pRelativeSD != NULL)
610 RtlFreeHeap(RtlGetProcessHeap(), 0, pRelativeSD);
611
612 if (hSecurityKey != NULL)
613 RegCloseKey(hSecurityKey);
614
615 return dwError;
616 }
617
618
619 DWORD
620 ScmDeleteRegKey(
621 _In_ HKEY hKey,
622 _In_ PCWSTR pszSubKey)
623 {
624 DWORD dwMaxSubkeyLen, dwMaxValueLen;
625 DWORD dwMaxLen, dwSize;
626 PWSTR pszName = NULL;
627 HKEY hSubKey;
628 DWORD dwError;
629
630 dwError = RegOpenKeyExW(hKey, pszSubKey, 0, KEY_READ, &hSubKey);
631 if (dwError != ERROR_SUCCESS)
632 return dwError;
633
634 /* Get maximum length of key and value names */
635 dwError = RegQueryInfoKeyW(hSubKey, NULL, NULL, NULL, NULL,
636 &dwMaxSubkeyLen, NULL, NULL, &dwMaxValueLen, NULL, NULL, NULL);
637 if (dwError != ERROR_SUCCESS)
638 goto done;
639
640 dwMaxSubkeyLen++;
641 dwMaxValueLen++;
642 dwMaxLen = max(dwMaxSubkeyLen, dwMaxValueLen);
643
644 /* Allocate the name buffer */
645 pszName = HeapAlloc(GetProcessHeap(), 0, dwMaxLen * sizeof(WCHAR));
646 if (pszName == NULL)
647 {
648 dwError = ERROR_NOT_ENOUGH_MEMORY;
649 goto done;
650 }
651
652 /* Recursively delete all the subkeys */
653 while (TRUE)
654 {
655 dwSize = dwMaxLen;
656 if (RegEnumKeyExW(hSubKey, 0, pszName, &dwSize,
657 NULL, NULL, NULL, NULL) != ERROR_SUCCESS)
658 {
659 break;
660 }
661
662 dwError = ScmDeleteRegKey(hSubKey, pszName);
663 if (dwError != ERROR_SUCCESS)
664 goto done;
665 }
666
667 done:
668 if (pszName != NULL)
669 HeapFree(GetProcessHeap(), 0, pszName);
670
671 RegCloseKey(hSubKey);
672
673 /* Finally delete the key */
674 if (dwError == ERROR_SUCCESS)
675 dwError = RegDeleteKeyW(hKey, pszSubKey);
676
677 return dwError;
678 }
679
680
681 DWORD
682 ScmDecryptPassword(
683 _In_ PBYTE pPassword,
684 _In_ DWORD dwPasswordSize,
685 _Out_ PWSTR *pClearTextPassword)
686 {
687 PWSTR pBuffer;
688
689 /* Allocate a buffer for the decrypted password */
690 pBuffer = HeapAlloc(GetProcessHeap(), 0, dwPasswordSize);
691 if (pBuffer == NULL)
692 return ERROR_OUTOFMEMORY;
693
694 /* Decrypt the password */
695 CopyMemory(pBuffer,
696 pPassword,
697 dwPasswordSize);
698
699 *pClearTextPassword = pBuffer;
700
701 return ERROR_SUCCESS;
702 }
703
704 /* EOF */