Tag: Servizi

Introduzione

Proseguiamo la serie sui servizi di Windows arricchendo il servizio scritto nella parte 1 con istruzioni per la creazione di un file con una ACL personalizzata.

Creazione di un file

In Windows l’API per la creazione di un file, da user-mode, è CreateFile.
La stessa funzione si utilizza anche per l’apertura di oggetti o device (vedremo cosa sono in post dedicati ai driver) e il valore restituito è sempre un handle.
Nel caso di errori il valore restituito è INVALID_HANDLE_VALUE.
Per ottenere il dettaglio dell’errore bisogna confrontare il valore restituito dalla funzione GetLastError con i codici errori di Windows: ad esempio il valore di ritorno pari a 0x5 corrisponde ad ERROR_ACCESS_DENIED.

HANDLE CreateFileW(
  [in]           LPCWSTR               lpFileName,
  [in]           DWORD                 dwDesiredAccess,
  [in]           DWORD                 dwShareMode,
  [in, optional] LPSECURITY_ATTRIBUTES lpSecurityAttributes,
  [in]           DWORD                 dwCreationDisposition,
  [in]           DWORD                 dwFlagsAndAttributes,
  [in, optional] HANDLE                hTemplateFile
);

Il primo parametro richiede il nome del file o del device da creare o aprire.

Il secondo parametro, dwDesiredAccess, richiede i permessi necessari per effettuare operazioni sul file che possono essere di sola lettura, solo modifica, lettura e modifica con un certo grado di granularità.
Infatti, è possibile specificare un valore generico come FILE_GENERIC_WRITE o un permesso specifico come FILE_APPEND_DATA, incluso in FILE_GENERIC_WRITE.

Il terzo parametro, dwShareMode, richiede il tipo di condivisione del file/device mentre ci sono degli handle aperti.
Se non si specifica un valore non sarà possibile aprire un altro handle fintanto che il primo rimane attivo.

dwCreationDisposition specifica il comportamento da mantenere durante la creazione/apertura del file nel caso questo non esista o sia già presente.

Con l‘handle ottenuto possiamo poi procedere a leggere il contenuto del file o a scriverne di nuovo.
Esempio di utilizzo:

g_FileHandle = CreateFile(
	L"C:\\LoggerSvc.log", // nome del file
	FILE_APPEND_DATA, // permesso per aggiungere dati alla fine del file
	FILE_SHARE_READ, // altri processi possono aprire il file in sola lettura
	&saFile,  // ACL
	OPEN_ALWAYS, // Apri sempre il file, se non esiste crealo
	FILE_ATTRIBUTE_NORMAL,
	nullptr);

Applicazione di ACL

Al paragrafo precedente non abbiamo commentato lo scopo del parametro lpSecurityAttributes.
Questo parametro accetta un puntatore a una struttura SECURITY_ATTRIBUTES:

typedef struct _SECURITY_ATTRIBUTES {
  DWORD  nLength;
  LPVOID lpSecurityDescriptor;
  BOOL   bInheritHandle;
} SECURITY_ATTRIBUTES, *PSECURITY_ATTRIBUTES, *LPSECURITY_ATTRIBUTES;

Questa struttura riceve un parametro nLength che corrisponde alla dimensione della struttura stessa (sizeof(SECURITY_ATTRIBUTES)), lpSecurityDescriptor che riceve un puntatore a una struttura SECURITY_DESCRIPTOR e bInheritHandle che determina se gli attributi saranno ereditati da un processo figlio.

Una struttura SECURITY_DESCRIPTOR contiene i valori che identificano le informazioni di sicurezza applicate a un oggetto, tra cui le ACL:

typedef struct _SECURITY_DESCRIPTOR {
  BYTE                        Revision;
  BYTE                        Sbz1;
  SECURITY_DESCRIPTOR_CONTROL Control;
  PSID                        Owner;
  PSID                        Group;
  PACL                        Sacl;
  PACL                        Dacl;
} SECURITY_DESCRIPTOR, *PISECURITY_DESCRIPTOR;

L’inizializzazione del security descriptor è affidata alla funzione InitializeSecurityDescriptor che prepara la struttura a ricevere nuove informazioni come la DACL (Discretionary Access List) di seguito passata con la funzione SetSecurityDescriptorDacl.

L’ACL è formata da una o più ACE (Access Control Entries) che sono inizializzate in strutture EXPLICIT_ACCESS.
I campi di questa struttura definiscono se i permessi di lettura, scrittura o esecuzione sono concessi o revocati.

typedef struct _EXPLICIT_ACCESS_W {
  DWORD       grfAccessPermissions; // permessi di lettura | scrittura | esecuzione
  ACCESS_MODE grfAccessMode;  // permessi concessi o negati
  DWORD       grfInheritance; // se e come l'ACL è ereditata da oggetti figlio
  TRUSTEE_W   Trustee; // utente, gruppo o servizio a cui si applica l'ACE
} EXPLICIT_ACCESS_W, *PEXPLICIT_ACCESS_W, EXPLICIT_ACCESSW, *PEXPLICIT_ACCESSW;

Una volta pronta la struttura viene aggiunta a una struttura ACL tramite la funzione SetEntriesInAcl.

Nel codice che segue vengono create due ACE, una che concede il controllo completo sul file a NT\SYSTEM e una che concede solo il permesso di lettura al gruppo Everyone.

PSID pEveryoneSid, pLocalSystemSid;
PACL pAclFile;
HANDLE hFile;

// Inizializzazione del SID per il gruppo noto Everyone
SID_IDENTIFIER_AUTHORITY sidAuthWorld = SECURITY_WORLD_SID_AUTHORITY;
if (!AllocateAndInitializeSid(&sidAuthWorld, 1, SECURITY_WORLD_RID, 0, 0, 0, 0, 0, 0, 0, &pEveryoneSid))
	SetStatus(SERVICE_STOPPED);

SID_IDENTIFIER_AUTHORITY sidAuthNt = SECURITY_NT_AUTHORITY;
if (!AllocateAndInitializeSid(&sidAuthNt, 1, SECURITY_LOCAL_SYSTEM_RID, 0, 0, 0, 0, 0, 0, 0, &pLocalSystemSid))
	SetStatus(SERVICE_STOPPED);

EXPLICIT_ACCESS eaFile[2];
ZeroMemory(&eaFile, 2 * sizeof(EXPLICIT_ACCESS));


// Creazione dell'ACE con permesso di sola lettura per il gruppo Everyone
eaFile[0].grfAccessPermissions = FILE_GENERIC_READ;
eaFile[0].grfAccessMode = SET_ACCESS;
eaFile[0].grfInheritance = NO_INHERITANCE;
eaFile[0].Trustee.pMultipleTrustee = nullptr;
eaFile[0].Trustee.MultipleTrusteeOperation = NO_MULTIPLE_TRUSTEE;
eaFile[0].Trustee.TrusteeForm = TRUSTEE_IS_SID;
eaFile[0].Trustee.TrusteeType = TRUSTEE_IS_WELL_KNOWN_GROUP;
eaFile[0].Trustee.ptstrName = (LPTCH)pEveryoneSid;

// Creazione dell'ACE con permessi di controllo completo per l'account LocalSystem
eaFile[1].grfAccessPermissions = FILE_ALL_ACCESS;
eaFile[1].grfAccessMode = SET_ACCESS;
eaFile[1].grfInheritance = NO_INHERITANCE;
eaFile[1].Trustee.pMultipleTrustee = nullptr;
eaFile[1].Trustee.MultipleTrusteeOperation = NO_MULTIPLE_TRUSTEE;
eaFile[1].Trustee.TrusteeForm = TRUSTEE_IS_SID;
eaFile[1].Trustee.TrusteeType = TRUSTEE_IS_USER;
eaFile[1].Trustee.ptstrName = (LPTCH)pLocalSystemSid;

// Aggiunta delle ACE nell'ACL
DWORD aclStatus = SetEntriesInAcl(2, eaFile, nullptr, &pAclFile);
if (aclStatus != ERROR_SUCCESS) {
	FreeSid(pLocalSystemSid);
	FreeSid(pEveryoneSid);
	SetStatus(SERVICE_STOPPED);
}

// Inizializzazione del Security Descriptor
SECURITY_DESCRIPTOR sdFile;
InitializeSecurityDescriptor(&sdFile, SECURITY_DESCRIPTOR_REVISION);
if (!SetSecurityDescriptorDacl(&sdFile, true, pAclFile, false) {
	FreeSid(pEveryoneSid);
	FreeSid(pLocalSystemSid);
	SetStatus(SERVICE_STOPPED);
}

// Inizializzazione della struttura SECURITY_ATTRIBUTES
SECURITY_ATTRIBUTES saFile;
saFile.nLength = sizeof(SECURITY_ATTRIBUTES);
saFile.lpSecurityDescriptor = &sdFile;
saFile.bInheritHandle = FALSE;

hFile = CreateFile(
	L"C:\\test.txt",
	FILE_APPEND_DATA,
	FILE_SHARE_READ,
	&saFile,
	OPEN_ALWAYS,
	FILE_ATTRIBUTE_NORMAL,
	nullptr);

Circa i SID (Security Identifiers) dedicherò in futuro un post, per il momento è sufficiente sapere che sono identificatori univoci con i quali Windows gestisce utenti, gruppi e account nei contesti di sicurezza.

Comparazione permessi con e senza ACL

Giunti a questo punto il codice del servizio sarà così:

#include <Windows.h>
#include <iostream>
#include <aclapi.h>

// Variabili globali
WCHAR g_ServiceName[] = L"LoggerSvc";
SERVICE_STATUS_HANDLE g_ServiceStatusHandle;
SERVICE_STATUS g_ServiceStatus;
HANDLE g_FileHandle;
BOOL g_Status;
PSID g_pEveryoneSid, g_pLocalSystemSid;


// Funzione wrapper attorno a SetServiceStatus per cambiare lo stato del servizio
void SetStatus(DWORD state) {
	g_ServiceStatus.dwCurrentState = state;
	SetServiceStatus(g_ServiceStatusHandle, &g_ServiceStatus);
}

// Funzione per gestire le richieste di control provenienti dal Service Control Handler
void WINAPI LoggerHandler(DWORD dwControl) {
	switch (dwControl) {
	case SERVICE_CONTROL_STOP:
		CloseHandle(g_FileHandle);
		FreeSid(g_pEveryoneSid);
		FreeSid(g_pLocalSystemSid);
		SetStatus(SERVICE_STOPPED);
	}
}


// Funzione ServiceMain
void WINAPI  LoggerSvcMain(DWORD dwNumServicesArgs, LPWSTR* lpServiceArgVectors) {
	// Registrazione dell'handler al SCM
	g_ServiceStatusHandle = RegisterServiceCtrlHandler(g_ServiceName, LoggerHandler);

	SetStatus(SERVICE_START_PENDING);

	// Inizializzazione dele risorse

	PACL pAclFile;

	// Inizializzazione del SID per il gruppo Everyone
	SID_IDENTIFIER_AUTHORITY sidAuthWorld = SECURITY_WORLD_SID_AUTHORITY;
	if (!AllocateAndInitializeSid(&sidAuthWorld, 1, SECURITY_WORLD_RID, 0, 0, 0, 0, 0, 0, 0, &g_pEveryoneSid))
		SetStatus(SERVICE_STOPPED);

	SID_IDENTIFIER_AUTHORITY sidAuthNt = SECURITY_NT_AUTHORITY;
	if (!AllocateAndInitializeSid(&sidAuthNt, 1, SECURITY_LOCAL_SYSTEM_RID, 0, 0, 0, 0, 0, 0, 0, &g_pLocalSystemSid))
		SetStatus(SERVICE_STOPPED);

	EXPLICIT_ACCESS eaFile[2];
	ZeroMemory(&eaFile, 2 * sizeof(EXPLICIT_ACCESS));

	// Inizializzazione del primo elemento EXPLICIT_ACCESS per accesso in sola lettura per il gruppo Everyone
	eaFile[0].grfAccessPermissions = FILE_GENERIC_READ;
	eaFile[0].grfAccessMode = SET_ACCESS;
	eaFile[0].grfInheritance = NO_INHERITANCE;
	eaFile[0].Trustee.pMultipleTrustee = nullptr;
	eaFile[0].Trustee.MultipleTrusteeOperation = NO_MULTIPLE_TRUSTEE;
	eaFile[0].Trustee.TrusteeForm = TRUSTEE_IS_SID;
	eaFile[0].Trustee.TrusteeType = TRUSTEE_IS_WELL_KNOWN_GROUP;
	eaFile[0].Trustee.ptstrName = (LPTCH)g_pEveryoneSid;

	// Inizializzazione del primo elemento EXPLICIT_ACCESS per accesso in controllo completo per l'account LocalSystem
	eaFile[1].grfAccessPermissions = FILE_ALL_ACCESS;
	eaFile[1].grfAccessMode = SET_ACCESS;
	eaFile[1].grfInheritance = NO_INHERITANCE;
	eaFile[1].Trustee.pMultipleTrustee = nullptr;
	eaFile[1].Trustee.MultipleTrusteeOperation = NO_MULTIPLE_TRUSTEE;
	eaFile[1].Trustee.TrusteeForm = TRUSTEE_IS_SID;
	eaFile[1].Trustee.TrusteeType = TRUSTEE_IS_USER;
	eaFile[1].Trustee.ptstrName = (LPTCH)g_pLocalSystemSid;

	// Creazione dell'ACL con le due ACE
	DWORD aclStatus = SetEntriesInAcl(2, eaFile, nullptr, &pAclFile);
	if (aclStatus != ERROR_SUCCESS) {
		FreeSid(g_pLocalSystemSid);
		FreeSid(g_pEveryoneSid);
		SetStatus(SERVICE_STOPPED);
	}

	// Inizializzazione del Security Descriptor
	SECURITY_DESCRIPTOR sdFile;
	InitializeSecurityDescriptor(&sdFile, SECURITY_DESCRIPTOR_REVISION);
	if (!SetSecurityDescriptorDacl(&sdFile, true, pAclFile, false)){
		FreeSid(g_pEveryoneSid);
		FreeSid(g_pLocalSystemSid);
		SetStatus(SERVICE_STOPPED);
	}

	// Inizializzazione degli attributi di sicurezza
	SECURITY_ATTRIBUTES saFile, saMailslot;
	saFile.nLength = sizeof(SECURITY_ATTRIBUTES);
	saFile.lpSecurityDescriptor = &sdFile;
	saFile.bInheritHandle = FALSE;

	// Creazione/apertura del file log
	g_FileHandle = CreateFile(
		L"C:\\LoggerSvc.log",
		FILE_APPEND_DATA,
		FILE_SHARE_READ,
		&saFile,
		OPEN_ALWAYS,
		FILE_ATTRIBUTE_NORMAL,
		nullptr);

	if (g_FileHandle == INVALID_HANDLE_VALUE) {
		FreeSid(g_pEveryoneSid);
		FreeSid(g_pLocalSystemSid);
		SetStatus(SERVICE_STOPPED);
	}

	// Set service status as running
	SetStatus(SERVICE_RUNNING);
}


int main(void) {
	
	// Array of services
	SERVICE_TABLE_ENTRY ServiceTableEntries[] = {
	{ g_ServiceName, LoggerSvcMain },
	{ nullptr }
	};

	// Determine if the service runs in its own process or the process is shared with other processes
	g_ServiceStatus.dwServiceType = SERVICE_WIN32_OWN_PROCESS;
	g_ServiceStatus.dwControlsAccepted = SERVICE_ACCEPT_STOP;

	// The main thread becomes the service control dispatcher and launch another thread with the service main function
	if (!StartServiceCtrlDispatcher(ServiceTableEntries))
		return 1;

	return 0;

}

Procediamo quindi alla compilazione del file e installazione del servizio nella macchina di test.
Appena avviamo il servizio possiamo verificare che il file è stato creato con successo.

Il file è creato con i criteri di sicurezza specificati, ovvero sola lettura per tutti gli utenti e permessi di controllo completo per l’account LocalSystem.
Se si prova a creare un file nella stessa directory, lasciando che erediti i criteri di sicurezza dalla cartella padre, i permessi sono diversi:

In questo modo è possibile proteggere quanto prodotto dal servizio, che sia un file o un mailslot, da utenti standard.
Da notare che un utente con poteri d’amministratore può effettuare l’override dei criteri di sicurezza degli oggetti e ottenerne l’accesso.

Conclusioni

I servizi sono un elemento importante in Windows e in ambito cybersecurity diventano cruciali per lo sviluppo di soluzioni EDR per il caricamento di driver e sensori.
Come vedremo, infatti, questa serie sui servizi si inserisce in un quadro più ampio di approfondimento sul funzionamento degli EDR e del kernel di Windows, con esempi pratici di sviluppo di driver software e tecniche di evasione.

Riferimenti

• CreateFileW function (fileapi.h) – Win32 apps | Microsoft Learn
• GetLastError function (errhandlingapi.h) – Win32 apps | Microsoft Learn
• Tutorial – Debug system error codes – Win32 apps | Microsoft Learn
• SECURITY_ATTRIBUTES – Win32 apps | Microsoft Learn
• SECURITY_DESCRIPTOR (winnt.h) – Win32 apps | Microsoft Learn
• Creating a Security Descriptor for a New Object in C++ – Win32 apps | Microsoft Learn
• InitiazliSecurityDescriptor | Microsoft Learn
• SetSecurityDescriptorDacl | Microsoft Learn
• SetEntriesinAcl | Microsoft Learn
• EXPLICIT_ACCESS
• ACL

Introduzione

Un servizio è un programma (.exe o .sys) che viene eseguito in background e non richiede interazione da parte dell’utente.
In Windows le informazioni relative ai servizi sono salvate al percorso del Registro di Sistema HKLM\SYSTEM\CurrentControlSet\Services, il quale contiene una chiave per ogni servizio.

Nella prima parte di questa serie sui servizi vedremo come crearne uno il cui file binario sarà un eseguibile (.exe), partendo da una veloce infarinatura fino all’installazione.

Struttura di un servizio

L’applicazione che andremo a scrivere sarà di tipo console, ovvero priva di GUI, così come una qualsiasi altra applicazione eseguibile da riga di comando ma che, per essere considerata un servizio valido, deve rispettare i requisiti richiesti da Windows.

Dall’immagine che segue si può da subito notare che il Processo del servizio utilizza due thread per funzionar correttamente: il main thread e il ervice thread.

Il main thread esegue il codice della funzione main (Service Entry Point) che si occupa di inizializzare una struttura SERVICE_TABLE_ENTRY:

typedef struct _SERVICE_TABLE_ENTRYW {
  LPWSTR                   lpServiceName;
  LPSERVICE_MAIN_FUNCTIONW lpServiceProc;
} SERVICE_TABLE_ENTRYW, *LPSERVICE_TABLE_ENTRYW;

Questa struttura contiene il nome del servizio e la sua funzione principale (ServiceMain).
La variabile di tipo SERVICE_TABLE deve essere un array che può contenere più di una coppia di valori, se lo stesso processo serve più servizi, ma la cui ultima voce deve corrispondere a un valore NULL, che sta ad indicare la fine dell’array.

SERVICE_TABLE_ENTRY entries[]: {
    {lpServiceName1, lpServiceProc1},
    {nullptr}
};

Successivamente invoca la funzione StartServiceControlDispatcher che connette il main thread al Service Control Manager (SCM), rendendolo di fatto il service control dispatcher thread del processo.
Il suo compito sarà, da quel momento in poi, la gestione delle richieste di modifica dello stato del servizio (avvio, arresto, sospensione…) provenienti dal Service Control Manager.

if(!StartServiceCtrlDispatcher(entries){
    return 1;
}

Giunti a questo punto il main thread avvia il service thread che esegue il codice della funzione principale del servizio, la ServiceMain.
La prima operazione che il service thread deve eseguire è la registrazione, tramite la funzione RegisterServiceCtrlHandler, di un handler che contiene il codice per gestire le richieste del SCM.
Successivamente notifica al SCM che il servizio è in stato di avvio (SERVICE_START_PENDING) e infine che è attivo (SERVICE_RUNNING) tramite la funzione SetServiceStatus e la struttura SERVICE_STATUS.
Il Service Control Manager è “impaziente” e deve essere notificato entro pochi secondi se il servizio è in avvio.
Qualora l’inizializzazione delle risorse necessarie richieda più tempo, è necessario indicare il tempo rimanente o invocare con cadenza regolare che il servizio è in fase di avvio (SERVICE_START_PENDING).

typedef struct _SERVICE_STATUS {
  DWORD dwServiceType;
  DWORD dwCurrentState;
  DWORD dwControlsAccepted;
  DWORD dwWin32ExitCode;
  DWORD dwServiceSpecificExitCode;
  DWORD dwCheckPoint;
  DWORD dwWaitHint;
} SERVICE_STATUS, *LPSERVICE_STATUS;

Scrittura del servizio

Quanto esposto sopra è un breve accenno ai passaggi fondamentali che l’applicazione deve seguire affinché Windows lo possa registrare come servizio ed eseguirlo senza errori.

Per avere una idea, il codice sarà così:

// Headers necessari
#include <Windows.h>

// Variabili globali
WCHAR g_ServiceName[] = L"NomeDelServizio";
SERVICE_STATUS_HANDLE g_ServiceHandle;
SERVICE_STATUS g_ServiceStatus;

// Funzione wrapper attorno a SetServiceStatus
void SetStatus(DWORD state) {
    g_ServiceStatus.dwCurrentState = state;
    SetServiceStatus(g_ServiceHandle, &g_ServiceStatus);
}

// Funzione handler che gestisce le richieste del SCM
void WINAPI ServiceHandler(DWORD dwControl){
    switch (dwControl) {
    case SERVICE_CONTROL_STOP:
        SetStatus(SERVICE_STOPPED);
        break;
    }
}

// Funzione principale del service thread
void WINAPI ServiceMain(DWORD dwNumServicesArgs, LPWSTR* lpServiceArgVectors) {
    
    // Registrazione della funzione handler
    g_ServiceHandle = RegisterServiceCtrlHandler(g_ServiceName, ServiceHandler);

    // Servizio in avvio
    SetStatus(SERVICE_START_PENDING);

    // Qualora fosse necessario inizializzare delle risorse il codice va inserito qui

    // Il servizio è avviato
    SetStatus(SERVICE_RUNNING);

}

// Funzione principale del processo eseguita nel main thread
int main(){

    // Inizializzazione della variabile di tipo SERVICE_TABLE_ENTRY
    SERVICE_TABLE_ENTRY entries[] = {
        {g_ServiceName, ServiceMain},
        {nullptr}
    };

    // Il servizio viene eseguito nel suo processo e accetta le richieste di arresto
    g_ServiceStatus.dwServiceType = SERVICE_WIN32_OWN_PROCESS;
    g_ServiceStatus.dwControlsAccepted = SERVICE_ACCEPT_STOP;

    // Avvia il service thread, in caso di errore chiude il processo
    if(!StartServiceCtrlDispatcher(entries))
        return 1;

    return 0;
}

Per compilare il codice è necessario avere a disposizione Visual Studio (anche edizione Community) con il SDK di Windows e le librerie per la compilazione (link alla guida dal sito Microsoft).
La compilazione in modalità Debug non consente la registrazione del servizio ed è quindi necessario selezionare la modalità Release, come mostrato nel video che segue.

A questo punto al percorso predefinito C:\Users\<nome utente>\sources\repos\<nome soluzione>\x64\Release si trovano il file eseguibile compilato e il file .pdb (utile per effettuare il debug del file).

Distribuzione, installazione e verifica

Il metodo più semplice per installare manualmente il servizio prevede di copiare il file eseguibile nella macchina test e utilizzare il comando sc da prompt dei comandi (cmd.exe) eseguito come amministratore.

Il comando per l’installazione è sc create <nome del servizio> type= own binPath= <percorso del file eseguibile>.
Da notare che gli spazi dopo type= e binPath= sono necessari.

Se il comando ha successo significa che il servizio è stato creato ma, per impostazione predefinita, non è ancora in esecuzione.
Per avviarlo è richiesto un input come sc start <nome del servizio>.

Come si vede dallo screenshot, il servizio è in esecuzione.
Essendo stato creato correttamente lo ritroviamo sia tra l’elenco dei servizi disponibili in Gestione dei servizi (services.msc) sia nel Registro di sistema.

Non avendo specificato diversamente, Windows crea il servizio in avvio manuale (Start 3) e in esecuzione sotto l’utente LocalSystem.
Per un maggiore controllo sulla creazione del servizio occorre scrivere una applicazione client che utilizzi l’API CreateService:

SC_HANDLE CreateServiceW(
  [in]            SC_HANDLE hSCManager,
  [in]            LPCWSTR   lpServiceName,
  [in, optional]  LPCWSTR   lpDisplayName,
  [in]            DWORD     dwDesiredAccess,
  [in]            DWORD     dwServiceType,
  [in]            DWORD     dwStartType,
  [in]            DWORD     dwErrorControl,
  [in, optional]  LPCWSTR   lpBinaryPathName,
  [in, optional]  LPCWSTR   lpLoadOrderGroup,
  [out, optional] LPDWORD   lpdwTagId,
  [in, optional]  LPCWSTR   lpDependencies,
  [in, optional]  LPCWSTR   lpServiceStartName,
  [in, optional]  LPCWSTR   lpPassword
);

Come si vede dal prototipo è possibile specificare il tipo di avvio (dwStartType), sotto quale utente deve essere eseguito (lpServiceStartName), il tipo di servizio (dwServiceType) e l’ordine di avvio nel caso di dipendenze (lpLoadOrderGroup).

Per fermare il servizio è sufficiente utilizzare il comando sc stop <nome del servizio> o il pulsante Arresta da Gestione dei servizi.

Conclusione e anticipazioni

In questa prima parte sono stati fissati i principali concetti riguardo ai servizi in Windows.
Nelle parti che seguiranno il servizio sarà ampliato in un progetto più ampio che includerà la creazione di file, la creazione di mailsllot, la creazione di un client e l’utilizzo di ACL (Access Control List).

Riferimenti

• https://learn.microsoft.com/en-us/windows/win32/services/service-entry-point
• https://learn.microsoft.com/en-us/windows/win32/api/winsvc/ns-winsvc-service_table_entryw
• https://learn.microsoft.com/en-us/windows/win32/api/winsvc/nf-winsvc-startservicectrldispatcherw
• https://learn.microsoft.com/en-us/windows/win32/services/service-control-manager
• https://learn.microsoft.com/en-us/windows/win32/services/service-servicemain-function
• https://learn.microsoft.com/en-us/windows/win32/api/winsvc/nf-winsvc-registerservicectrlhandlerw
• https://learn.microsoft.com/en-us/windows/win32/services/service-control-handler-function
• https://learn.microsoft.com/en-us/windows/win32/api/winsvc/nf-winsvc-setservicestatus
• https://learn.microsoft.com/en-us/windows/win32/services/service-status-transitions
• https://learn.microsoft.com/en-us/windows/win32/api/winsvc/ns-winsvc-service_status
• https://learn.microsoft.com/en-us/windows-hardware/drivers/download-the-wdk
• https://learn.microsoft.com/en-us/windows/win32/api/winsvc/nf-winsvc-createservicew