DEV Community: issam boutissante

How to Read/Write from Credential Manager in .NET 8

issam boutissante — Wed, 05 Jun 2024 10:15:05 +0000

How to Read/Write from Credential Manager in .NET 8

Credential Manager is a secure storage solution for sensitive information, such as usernames and passwords. It provides a way to manage credentials for various applications securely. In this article, we will walk through the steps to read, write, update, and delete credentials in .NET 8 using the Meziantou.Framework.Win32 library, which also works in .NET 6 and 7.

Setting Up the Project

Before we dive into the code, ensure you have the following NuGet package installed in your .NET project:

dotnet add package Meziantou.Framework.Win32

Writing Credentials to Credential Manager

To securely save credentials, we can use the CredentialManager.WriteCredential method. Here is a step-by-step guide:

Define the Credential Information:
- applicationName: A unique identifier for the application.
- userName: The username associated with the credential.
- secret: The password or sensitive information.
- comment: A description for the credential.
- persistence: Determines how the credential is stored (Session, LocalMachine, Enterprise).

using Meziantou.Framework.Win32;
using System;

public class CredentialManagerHelper
{
    public static void SaveCredential(string applicationName, string userName, string secret, string comment, CredentialPersistence persistence)
    {
        CredentialManager.WriteCredential(
            applicationName: applicationName,
            userName: userName,
            secret: secret,
            comment: comment,
            persistence: persistence);
    }
}

Usage Example:

class Program
{
    static void Main(string[] args)
    {
        string appName = "MyApp";
        string userName = "user123";
        string password = "P@ssw0rd!";
        string comment = "User login information";

        CredentialManagerHelper.SaveCredential(appName, userName, password, comment, CredentialPersistence.LocalMachine);

        Console.WriteLine("Credential saved successfully.");
    }
}

Reading Credentials from Credential Manager

To retrieve the stored credentials, use the CredentialManager.ReadCredential method:

public class CredentialManagerHelper
{
    public static Credential ReadCredential(string applicationName)
    {
        var credential = CredentialManager.ReadCredential(applicationName);
        if (credential == null)
        {
            Console.WriteLine("No credential found.");
            return null;
        }

        Console.WriteLine($"UserName: {credential.UserName}");
        Console.WriteLine($"Secret: {credential.Password}");
        Console.WriteLine($"Comment: {credential.Comment}");

        return credential;
    }
}

Updating Credentials

Updating a credential is straightforward. Simply call the SaveCredential method again with the same applicationName:

public static void UpdateCredential(string applicationName, string newUserName, string newSecret, string newComment)
{
    SaveCredential(applicationName, newUserName, newSecret, newComment, CredentialPersistence.LocalMachine);
}

Deleting Credentials

To remove a credential, use the CredentialManager.DeleteCredential method:

public class CredentialManagerHelper
{
    public static void DeleteCredential(string applicationName)
    {
        try
        {
            CredentialManager.DeleteCredential(applicationName);
            Console.WriteLine("Credential deleted successfully.");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error deleting credential: {ex.Message}");
        }
    }
}

Understanding Credential Persistence

The CredentialPersistence enumeration defines how credentials are stored:

Session: Credentials are only available for the current session.
LocalMachine: Credentials are saved for the current user on the local machine and are not accessible by other users.
Enterprise: Credentials are available to all authenticated users on the domain.

public enum CredentialPersistence : uint
{
    Session = 1,
    LocalMachine,
    Enterprise,
}

Full Example

Here is a complete example that demonstrates creating, reading, updating, and deleting credentials:

using Meziantou.Framework.Win32;
using System;

public class CredentialManagerHelper
{
    public static void SaveCredential(string applicationName, string userName, string secret, string comment, CredentialPersistence persistence)
    {
        CredentialManager.WriteCredential(
            applicationName: applicationName,
            userName: userName,
            secret: secret,
            comment: comment,
            persistence: persistence);
    }

    public static Credential ReadCredential(string applicationName)
    {
        var credential = CredentialManager.ReadCredential(applicationName);
        if (credential == null)
        {
            Console.WriteLine("No credential found.");
            return null;
        }

        Console.WriteLine($"UserName: {credential.UserName}");
        Console.WriteLine($"Secret: {credential.Password}");
        Console.WriteLine($"Comment: {credential.Comment}");

        return credential;
    }

    public static void UpdateCredential(string applicationName, string newUserName, string newSecret, string newComment)
    {
        SaveCredential(applicationName, newUserName, newSecret, newComment, CredentialPersistence.LocalMachine);
    }

    public static void DeleteCredential(string applicationName)
    {
        try
        {
            CredentialManager.DeleteCredential(applicationName);
            Console.WriteLine("Credential deleted successfully.");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error deleting credential: {ex.Message}");
        }
    }
}

class Program
{
    static void Main(string[] args)
    {
        string appName = "MyApp";
        string userName = "user123";
        string password = "P@ssw0rd!";
        string comment = "User login information";

        // Save credential
        CredentialManagerHelper.SaveCredential(appName, userName, password, comment, CredentialPersistence.LocalMachine);
        Console.WriteLine("Credential saved successfully.");

        // Read credential
        CredentialManagerHelper.ReadCredential(appName);

        // Update credential
        CredentialManagerHelper.UpdateCredential(appName, "newUser", "NewP@ssw0rd!", "Updated user login information");

        // Read updated credential
        CredentialManagerHelper.ReadCredential(appName);

        // Delete credential
        CredentialManagerHelper.DeleteCredential(appName);
    }
}

Conclusion

In this article, we've covered how to read, write, update, and delete credentials using the Credential Manager in .NET 8. This approach ensures that sensitive information is stored securely, leveraging the built-in capabilities of the Windows operating system. By following these steps, you can manage your application's credentials securely and efficiently.

Feel free to reach out with any questions or feedback in the comments below!

Creating a Single Bundle Configuration for Create React App

issam boutissante — Mon, 03 Jun 2024 19:25:36 +0000

Creating a Single Bundle Configuration for Create React App

In this guide, I'll walk you through the process of configuring a Create React App (CRA) based project to generate a single JavaScript file and inline all CSS and JavaScript directly into the index.html. This is particularly useful when the application needs to be embedded in environments that do not support multiple file references, such as certain mobile application frameworks.

Background

By default, CRA splits the application code into various chunks to optimize load performance. However, this default behavior can be altered to bundle the entire application code into a single file. Additionally, Gulp is used to inline all the assets into index.html, creating a self-contained application.

Steps

The configuration involves two main steps:

Disabling Code Splitting in CRA.
Inlining all assets into index.html using Gulp.

Step 1: Disabling Code Splitting

To prevent CRA from splitting the code into chunks, we use react-app-rewired along with customize-cra. These tools allow us to modify the internal webpack configuration without ejecting.

Install react-app-rewired and customize-cra:

   npm install react-app-rewired customize-cra --save-dev

Create a config-overrides.js file in the root directory with the following content:

   // config-overrides.js
   const { override } = require("customize-cra");

   module.exports = override((config) => {
     config.optimization.splitChunks = {
       cacheGroups: {
         default: false,
       },
     };
     config.optimization.runtimeChunk = false;
     return config;
   });

Step 2: Inlining Assets with Gulp

Gulp automates the inlining of CSS and JS into index.html.

Install Gulp and related plugins:

   npm install gulp gulp-inline-source gulp-replace gulp-cheerio --save-dev

Set up the gulpfile.js:

   // gulpfile.js
   const gulp = require("gulp");
   const inlineSource = require("gulp-inline-source");
   const replace = require("gulp-replace");
   const cheerio = require("gulp-cheerio");

   gulp.task("default", () => {
     return gulp
       .src("./build/*.html")
       .pipe(
         cheerio(($) => {
           const scriptTag = $("script[defer]");
           $("body").append(scriptTag);
         })
       )
       .pipe(replace('.js"></script>', '.js" inline></script>'))
       .pipe(replace('rel="stylesheet">', 'rel="stylesheet" inline>'))
       .pipe(
         inlineSource({
           compress: false,
           ignore: ["png"],
         })
       )
       .pipe(gulp.dest("./build"));
   });

Step 3: Environment Variables

Use a .env file to set environment variables for the build process:

INLINE_RUNTIME_CHUNK=false
GENERATE_SOURCEMAP=false
SKIP_PREFLIGHT_CHECK=true

Step 4: Modifying package.json

Update the package.json to use react-app-rewired:

"scripts": {
  "start": "react-app-rewired start",
  "build": "react-app-rewired build && npx gulp",
  "test": "react-app-rewired test",
  "eject": "react-scripts eject"
},

Note: Ensure that you remove any code that forces chunks, such as the following, from your application:

// If you want to start measuring performance in your app, pass a function
// to log results (for example: reportWebVitals(console.log))
// or send to an analytics endpoint. Learn more: https://bit.ly/CRA-vitals
reportWebVitals();

Step 5: Running the Build

After setting up, run the build command to generate the single bundle and inline assets:

npm run build

The build script will create a production build with a single JavaScript file, and the Gulp command will inline all resources into the index.html.

Conclusion

Following this configuration allows you to package a CRA application into a single index.html file with all assets inlined. This setup is suitable for use cases that require a standalone file for the entire application. It is recommended to thoroughly test the application after these modifications to ensure functionality remains intact.

Feel free to reach out if you have any questions or run into issues. Happy coding!

Creating Shell Extensions in .NET 8 with SharpShell

issam boutissante — Mon, 03 Jun 2024 13:51:16 +0000

In this blog, I'll walk you through creating a Windows shell extension using the SharpShell library in .NET 8. SharpShell is a popular library for creating shell extensions, but it was traditionally used with the .NET Framework. Thanks to the Microsoft Windows Compatibility Pack, it's now possible to create shell extensions in .NET 8.

Prerequisites

Visual Studio 2022 or later
.NET 8 SDK
Basic knowledge of C# and Windows shell extensions

Step 1: Create a .NET 8 Class Library

First, we need to create a .NET 8 class library. Open Visual Studio and create a new project:

Select Class Library.
Name the project SharpShellNet8Demo.
Choose .NET 8.0 as the target framework.

Step 2: Modify the .csproj File

Next, we need to download and include the necessary packages: Microsoft.Windows.Compatibility and SharpShell. Modify the project file (.csproj) to target only Windows and include these packages:

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <TargetFramework>net8.0-windows</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
    <UseWindowsForms>true</UseWindowsForms>
    <EnableComHosting>true</EnableComHosting>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="Microsoft.Windows.Compatibility" Version="8.0.4" />
    <PackageReference Include="SharpShell" Version="2.7.2" />
  </ItemGroup>

</Project>

Why we use these properties:

<UseWindowsForms>true</UseWindowsForms>: Enables Windows Forms support in the project.
<EnableComHosting>true</EnableComHosting>: Enables COM hosting support, necessary for registering shell extensions.

Step 3: Create a Context Menu Extension

Next, we'll create a simple context menu extension. Add a new class to your project named SimpleContextMenu.cs and implement the following code:

using SharpShell.Attributes;
using SharpShell.SharpContextMenu;
using System;
using System.Linq;
using System.Runtime.InteropServices;
using System.Windows.Forms;

namespace SharpShellNet8Demo
{
    [ComVisible(true)]
    [ClassInterface(ClassInterfaceType.None)]
    [COMServerAssociation(AssociationType.AllFilesAndFolders)]
    [COMServerAssociation(AssociationType.Directory)]
    [COMServerAssociation(AssociationType.DirectoryBackground)]
    [Guid("B3B9C5B6-5C92-4D1B-85E6-2F80B72F6E28")]
    public class SimpleContextMenu : SharpContextMenu
    {
        protected override bool CanShowMenu() => true;

        protected override ContextMenuStrip CreateMenu()
        {
            var menu = new ContextMenuStrip();

            var mainItem = new ToolStripMenuItem
            {
                Text = "Simple Extension Action"
            };

            var actionItem = new ToolStripMenuItem
            {
                Text = "Perform Action"
            };
            actionItem.Click += (sender, e) => MessageBox.Show("Action performed!");

            mainItem.DropDownItems.Add(actionItem);
            menu.Items.Add(mainItem);

            return menu;
        }

        [ComRegisterFunction]
        public static void Register(Type t)
        {
            RegisterContextMenu(t, @"*\shellex\ContextMenuHandlers\");
            RegisterContextMenu(t, @"Directory\shellex\ContextMenuHandlers\");
            RegisterContextMenu(t, @"Directory\Background\shellex\ContextMenuHandlers\");
        }

        private static void RegisterContextMenu(Type t, string basePath)
        {
            string keyPath = basePath + "SimpleContextMenu";
            using (var key = Microsoft.Win32.Registry.ClassesRoot.CreateSubKey(keyPath))
            {
                if (key == null)
                {
                    Console.WriteLine($"Failed to create registry key: {keyPath}");
                }
                else
                {
                    key.SetValue(null, t.GUID.ToString("B"));
                }
            }
        }

        [ComUnregisterFunction]
        public static void Unregister(Type t)
        {
            UnregisterContextMenu(@"*\shellex\ContextMenuHandlers\");
            UnregisterContextMenu(@"Directory\shellex\ContextMenuHandlers\");
            UnregisterContextMenu(@"Directory\Background\shellex\ContextMenuHandlers\");
        }

        private static void UnregisterContextMenu(string basePath)
        {
            string keyPath = basePath + "SimpleContextMenu";
            try
            {
                Microsoft.Win32.Registry.ClassesRoot.DeleteSubKeyTree(keyPath, false);
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Error unregistering COM server from {keyPath}: {ex.Message}");
            }
        }
    }
}

Explanation of Attributes

[ComVisible(true)]: Makes the class visible to COM components.
[ClassInterface(ClassInterfaceType.None)]: Specifies that no class interface is generated for the class.
[COMServerAssociation(AssociationType.AllFilesAndFolders)]: Registers the shell extension for all files and folders.
[COMServerAssociation(AssociationType.Directory)]: Registers the shell extension for directories.
[COMServerAssociation(AssociationType.DirectoryBackground)]: Registers the shell extension for the background of directories.
[Guid("B3B9C5B6-5C92-4D1B-85E6-2F80B72F6E28")]: Assigns a unique identifier to the class. Generate this GUID using Tools > Create GUID in Visual Studio.

Step 4: Register and Unregister the Extension

To test our shell extension, we need to register and unregister it. Create two batch files, Register.bat and Unregister.bat, to handle this.

Register.bat

@echo off
:: Check for administrative privileges
net session >nul 2>&1
if %errorlevel% == 0 (
    echo Running with administrative privileges
) else (
    echo Requesting administrative privileges...
    goto UACPrompt
)

goto Start

:UACPrompt
    echo Set UAC = CreateObject^("Shell.Application"^) > "%temp%\getadmin.vbs"
    echo UAC.ShellExecute "%~s0", "", "", "runas", 1 >> "%temp%\getadmin.vbs"
    "%temp%\getadmin.vbs"
    exit /B

:Start
cd /d "%~dp0"

:: Find DLL files ending with comhost.dll
for /f "delims=" %%a in ('dir /b *comhost.dll') do set "DLLFile=%%a"
if defined DLLFile goto Found

echo No DLL file ending with comhost.dll found, please enter the DLL name:
SET /P DLLName=Enter the DLL name to register (include .dll extension):
set DLLFile=%DLLName%

:Found
if not exist "%DLLFile%" (
    echo The specified DLL file does not exist.
    pause
    exit /b
)

regsvr32 /s "%DLLFile%"
taskkill /f /im explorer.exe
start explorer.exe
echo %DLLFile% registered and Explorer restarted.
pause

Unregister.bat

@echo off
:: Check for administrative privileges
net session >nul 2>&1
if %errorlevel% == 0 (
    echo Running with administrative privileges
) else (
    echo Requesting administrative privileges...
    goto UACPrompt
)

goto Start

:UACPrompt
    echo Set UAC = CreateObject^("Shell.Application"^) > "%temp%\getadmin.vbs"
    echo UAC.ShellExecute "%~s0", "", "", "runas", 1 >> "%temp%\getadmin.vbs"
    "%temp%\getadmin.vbs"
    exit /B

:Start
cd /d "%~dp0"

:: Find DLL files ending with comhost.dll
for /f "delims=" %%a in ('dir /b *comhost.dll') do set "DLLFile=%%a"
if defined DLLFile goto Found

echo No DLL file ending with comhost.dll found, please enter the DLL name:
SET /P DLLName=Enter the DLL name to unregister (include .dll extension):
set DLLFile=%DLLName%

:Found
if not exist "%DLLFile%" (
    echo The specified DLL file does not exist.
    pause
    exit /b
)

regsvr32 /u /s "%DLLFile%"
taskkill /f /im explorer.exe
start explorer.exe
echo %DLLFile% unregistered and Explorer restarted.
pause

Step 5: Build and Register the Extension

Build your project in Visual Studio.
Navigate to the output directory (usually bin\Debug\net8.0-windows).
Run Register.bat as an administrator to register the shell extension.
Right-click on any file or folder to see the new context menu option "Simple Extension Action".

Step 6: Unregister the Extension

When you want to unregister the shell extension, run Unregister.bat as an administrator. If you want to make any modifications to the project, you should unregister it first to avoid build errors caused by the DLL being in use. To prevent this issue, consider registering a copy of the net8.0-windows output, not the original `net8.0-w

indows` directory.

Conclusion

Creating a shell extension in .NET 8 using SharpShell and the Microsoft Windows Compatibility Pack is straightforward. This tutorial covered setting up your project, writing the shell extension code, and handling registration and unregistration. Experiment with different types of extensions to enhance your Windows Explorer experience!

Feel free to reach out if you have any questions or run into issues. Happy coding!