Delen via

Slimme kaarten

In dit onderwerp wordt uitgelegd hoe Windows-apps smartcards kunnen gebruiken om gebruikers te verbinden met beveiligde netwerkservices, waaronder het openen van fysieke smartcardlezers, het maken van virtuele smartcards, het communiceren met smartcards, het verifiëren van gebruikers, het opnieuw instellen van pincodes van gebruikers en het verwijderen of verbreken van smartcards.

De WinRT-API's (Windows Runtime) voor smartcards maken deel uit van de Windows Software Development Kit (SDK). Deze API's zijn gemaakt voor gebruik in UWP-apps (Universal Windows Platform), maar ze kunnen ook worden gebruikt in WinUI-apps of in verpakte bureaublad-apps, waaronder WPF en Windows Forms. Zie Windows Runtime-API's aanroepen in desktop-apps voor meer informatie over het gebruik van WinRT-API's in uw Windows-bureaublad-app.

Het app-manifest configureren

Voordat uw app gebruikers kan verifiëren met behulp van smartcards of virtuele smartcards, moet u de mogelijkheid Gedeelde gebruikerscertificaten instellen in het project Package.appxmanifest-bestand van uw WinUI-project of pakketproject.

Toegang tot verbonden kaartlezers en smartcards

U kunt een query uitvoeren op lezers en gekoppelde smartcards door de apparaat-id (opgegeven in DeviceInformation) door te geven aan de methode SmartCardReader.FromIdAsync . Als u toegang wilt krijgen tot de smartcards die momenteel zijn gekoppeld aan het geretourneerde lezerapparaat, roept u SmartCardReader.FindAllCardsAsync aan.

string selector = SmartCardReader.GetDeviceSelector();
DeviceInformationCollection devices =
    await DeviceInformation.FindAllAsync(selector);

foreach (DeviceInformation device in devices)
{
    SmartCardReader reader =
        await SmartCardReader.FromIdAsync(device.Id);

    // For each reader, we want to find all the cards associated
    // with it. Then we will create a SmartCardListItem for
    // each (reader, card) pair.
    IReadOnlyList<SmartCard> cards =
        await reader.FindAllCardsAsync();
}

U moet uw app ook inschakelen voor CardAdded-gebeurtenissen door een methode te implementeren voor het afhandelen van app-gedrag bij het invoegen van kaarten.

private void reader_CardAdded(SmartCardReader sender, CardAddedEventArgs args)
{
  // A card has been inserted into the sender SmartCardReader.
}

Vervolgens kunt u elk geretourneerd SmartCard-object doorgeven aan SmartCardProvisioning om toegang te krijgen tot de methoden waarmee uw app toegang heeft tot en de configuratie kan aanpassen.

Een virtuele smartcard maken

Als u een virtuele smartcard wilt maken met SmartCardProvisioning, moet uw app eerst een beschrijvende naam, een beheerderssleutel en een SmartCardPinPolicy opgeven. De beschrijvende naam is over het algemeen iets dat aan de app wordt verstrekt, maar uw app moet nog steeds een beheerderssleutel opgeven en een exemplaar van de huidige SmartCardPinPolicy genereren voordat alle drie de waarden worden doorgegeven aan RequestVirtualSmartCardCreationAsync.

  1. Een nieuw exemplaar van een SmartCardPinPolicy maken
  2. Genereer de waarde van de beheersleutel door CryptographicBuffer.GenerateRandom aan te roepen op de waarde van de beheersleutel die wordt geleverd door de service of het beheerprogramma.
  3. Geef deze waarden door samen met de FriendlyNameText-tekenreeks door aan RequestVirtualSmartCardCreationAsync.
var pinPolicy = new SmartCardPinPolicy
    {
        MinLength = 6
    };

IBuffer adminkey = CryptographicBuffer.GenerateRandom(24);

SmartCardProvisioning provisioning = await
     SmartCardProvisioning.RequestVirtualSmartCardCreationAsync(
          "Card friendly name",
          adminkey,
          pinPolicy);

Zodra RequestVirtualSmartCardCreationAsync het bijbehorende SmartCardProvisioning-object heeft geretourneerd, wordt de virtuele smartcard ingericht en klaar voor gebruik.

Opmerking

Als u een virtuele smartcard wilt maken met behulp van een verpakte Windows-app, moet de gebruiker die de app uitvoert lid zijn van de beheerdersgroep. Als de gebruiker geen lid is van de beheerdersgroep, mislukt het maken van virtuele smartcards.

Problemen met verificatie afhandelen

Als u wilt verifiëren met smartcards of virtuele smartcards, moet uw app het gedrag bieden om uitdagingen te voltooien tussen de op de kaart opgeslagen beheerderssleutelgegevens en de beheersleutelgegevens die worden onderhouden door de verificatieserver of het beheerhulpprogramma.

De beheerderssleutel verkrijgen

Voordat u verificatie kunt uitvoeren, moet u de beheersleutel verkrijgen. De bron van de beheersleutel is afhankelijk van uw scenario:

  • Voor virtuele smartcards die u hebt gemaakt: gebruik dezelfde beheerderssleutel die is gegenereerd tijdens het maken van kaarten (zoals wordt weergegeven in de sectie Een virtuele smartcard maken hierboven). U moet deze sleutel veilig opslaan voor later gebruik van verificatie.
  • Voor bestaande fysieke of virtuele smartcards: de beheersleutel wordt doorgaans geleverd door de IT-afdeling van uw organisatie, het kaartbeheersysteem of de service die de kaart heeft uitgegeven.
  • Voor ontwikkeling/testen: U kunt een testbeheerderssleutel genereren met cryptographicBuffer.GenerateRandom , zoals wordt weergegeven in het onderstaande voorbeeld van het maken van virtuele kaarten.
// Example: Store the admin key from virtual card creation for later use
IBuffer adminkey = CryptographicBuffer.GenerateRandom(24);

// Store this key securely in your app (e.g., in app settings, secure storage, etc.)
// You'll need this same key for authentication operations

SmartCardProvisioning provisioning = await
     SmartCardProvisioning.RequestVirtualSmartCardCreationAsync(
          "Card friendly name",
          adminkey,
          pinPolicy);

// Save the adminkey for future authentication
SaveAdminKeySecurely(adminkey);

Voorbeeldbeheermethoden voor beheerderssleutels

Hier volgen voorbeelden van methoden die u kunt implementeren om beheerderssleutels veilig op te slaan en op te halen:

// Example implementation for storing admin key securely
private void SaveAdminKeySecurely(IBuffer adminKey)
{
    // Convert to string for storage (consider encryption for production)
    string adminKeyString = CryptographicBuffer.EncodeToBase64String(adminKey);
    
    // Store in app settings (consider using Windows Credential Manager for production)
    ApplicationData.Current.LocalSettings.Values["SmartCardAdminKey"] = adminKeyString;
}

// Example implementation for retrieving stored admin key
private IBuffer GetStoredAdminKey()
{
    // Retrieve from app settings
    string adminKeyString = ApplicationData.Current.LocalSettings.Values["SmartCardAdminKey"] as string;
    
    if (string.IsNullOrEmpty(adminKeyString))
    {
        throw new InvalidOperationException("Admin key not found. Ensure the smart card was created by this app or the admin key was provided by your IT department.");
    }
    
    // Convert back to IBuffer
    return CryptographicBuffer.DecodeFromBase64String(adminKeyString);
}

Verificatie-algoritme

De volgende code laat zien hoe u smartcardverificatie kunt ondersteunen voor services of het wijzigen van fysieke of virtuele kaartgegevens. Als de gegevens die worden gegenereerd met behulp van de beheersleutel op de kaart ('uitdaging') hetzelfde zijn als de beheersleutelgegevens van het server- of beheerprogramma ('adminkey'),is verificatie geslaagd.

static class ChallengeResponseAlgorithm
{
    public static IBuffer CalculateResponse(IBuffer challenge, IBuffer adminkey)
    {
        if (challenge == null)
            throw new ArgumentNullException("challenge");
        if (adminkey == null)
            throw new ArgumentNullException("adminkey");

        SymmetricKeyAlgorithmProvider objAlg = SymmetricKeyAlgorithmProvider.OpenAlgorithm(SymmetricAlgorithmNames.TripleDesCbc);
        var symmetricKey = objAlg.CreateSymmetricKey(adminkey);
        var buffEncrypted = CryptographicEngine.Encrypt(symmetricKey, challenge, null);
        return buffEncrypted;
    }
}

In de rest van dit onderwerp ziet u deze code waarin wordt verwezen naar hoe u een verificatieactie voltooit en hoe u wijzigingen kunt toepassen op informatie over smartcards en virtuele smartcards.

Antwoord op smartcard- of virtuele smartcardverificatie controleren

Nu we de logica voor verificatieproblemen hebben gedefinieerd, kunnen we communiceren met de lezer om toegang te krijgen tot de smartcard, of om toegang te krijgen tot een virtuele smartcard voor verificatie.

  1. Als u de uitdaging wilt starten, roept u GetChallengeContextAsync aan vanuit het SmartCardProvisioning-object dat is gekoppeld aan de smartcard. Hiermee wordt een exemplaar van SmartCardChallengeContext gegenereerd, dat de waarde uitdaging van de kaart bevat.
  2. Geef vervolgens de waarde van de vraag van de kaart en de beheerderssleutel van de service of het beheerprogramma door aan de ChallengeResponseAlgorithm die we in het vorige voorbeeld hebben gedefinieerd.
  3. Controleer ofResponseAsyncwaar retourneert als de verificatie is geslaagd.
bool verifyResult = false;
SmartCard card = await rootPage.GetSmartCard();
SmartCardProvisioning provisioning =
    await SmartCardProvisioning.FromSmartCardAsync(card);

SmartCardChallengeContext context =
    await provisioning.GetChallengeContextAsync();

// Use the admin key that was either:
// 1. Generated during virtual card creation, or
// 2. Provided by your IT department/card management system
IBuffer adminKey = GetStoredAdminKey(); // Your method to retrieve the stored admin key

IBuffer response = ChallengeResponseAlgorithm.CalculateResponse(
    context.Challenge,
    adminKey);

verifyResult = await context.VerifyResponseAsync(response);

Een gebruikerspincode wijzigen of opnieuw instellen

De pincode wijzigen die is gekoppeld aan een smartcard:

  1. Open de kaart en genereer het bijbehorende SmartCardProvisioning-object .
  2. Roep RequestPinChangeAsync aan om een gebruikersinterface weer te geven aan de gebruiker om deze bewerking te voltooien.
  3. Als de pincode is gewijzigd, retourneert de aanroep waar.
SmartCardProvisioning provisioning =
    await SmartCardProvisioning.FromSmartCardAsync(card);

bool result = await provisioning.RequestPinChangeAsync();

Een pincode opnieuw instellen aanvragen:

  1. Roep RequestPinResetAsync aan om de bewerking te starten. Deze aanroep bevat een SmartCardPinResetHandler-methode die de smartcard en de aanvraag voor het opnieuw instellen van de pincode vertegenwoordigt.
  2. SmartCardPinResetHandler biedt informatie die onze ChallengeResponseAlgorithm, verpakt in een SmartCardPinResetDeferral-aanroep , gebruikt om de vraagwaarde van de kaart en de beheerderssleutel te vergelijken die wordt geleverd door de service of het beheerprogramma om de aanvraag te verifiëren.
  3. Als de uitdaging is geslaagd, wordt de aanroep RequestPinResetAsync voltooid; retourneert waar als de pincode opnieuw is ingesteld.
SmartCardProvisioning provisioning =
    await SmartCardProvisioning.FromSmartCardAsync(card);

bool result = await provisioning.RequestPinResetAsync(
    (pinResetSender, request) =>
    {
        SmartCardPinResetDeferral deferral =
            request.GetDeferral();

        try
        {
            // Use the same admin key from card creation or your secure storage
            IBuffer adminKey = GetStoredAdminKey(); // Your method to retrieve the stored admin key
            
            IBuffer response =
                ChallengeResponseAlgorithm.CalculateResponse(
                    request.Challenge,
                    adminKey);
            request.SetResponse(response);
        }
        finally
        {
            deferral.Complete();
        }
    });
}

Een smartcard of virtuele smartcard verwijderen

Wanneer een fysieke smartcard wordt verwijderd, wordt een cardRemoved-gebeurtenis geactiveerd wanneer de kaart wordt verwijderd.

Koppel het activeren van deze gebeurtenis aan de kaartlezer met de methode waarmee het gedrag van uw app bij het verwijderen van kaarten of lezers als gebeurtenis-handler wordt gedefinieerd. Dit gedrag kan net zo eenvoudig zijn als het verstrekken van meldingen aan de gebruiker dat de kaart is verwijderd.

reader = card.Reader;
reader.CardRemoved += HandleCardRemoved;

Het verwijderen van een virtuele smartcard wordt programmatisch verwerkt door eerst de kaart op te halen en vervolgens RequestVirtualSmartCardDeletionAsync aan te roepen vanuit het geretourneerde object SmartCardProvisioning .

bool result = await SmartCardProvisioning
    .RequestVirtualSmartCardDeletionAsync(card);

Verwante inhoud

  • Last updated on