Udostępnij przez

Karty inteligentne

W tym temacie opisano, jak aplikacje systemu Windows mogą używać kart inteligentnych do łączenia użytkowników z zabezpieczeniami usług sieciowych, w tym sposobu uzyskiwania dostępu do fizycznych czytników kart inteligentnych, tworzenia wirtualnych kart inteligentnych, komunikowania się z kartami inteligentnymi, uwierzytelniania użytkowników, resetowania numerów PIN użytkowników i usuwania lub odłączania kart inteligentnych.

Interfejsy API środowiska uruchomieniowego systemu Windows (WinRT) dla kart inteligentnych są częścią zestawu Windows Software Development Kit (SDK). Te interfejsy API zostały utworzone do użycia w aplikacjach platformy uniwersalnej systemu Windows (UWP), ale mogą być również używane w aplikacjach WinUI lub w spakowanych aplikacjach klasycznych, w tym WPF i Windows Forms. Aby uzyskać więcej informacji na temat używania interfejsów API WinRT w aplikacji klasycznej systemu Windows, zobacz Wywoływanie interfejsów API środowiska uruchomieniowego systemu Windows w aplikacjach klasycznych.

Konfigurowanie manifestu aplikacji

Aby aplikacja mogła uwierzytelniać użytkowników przy użyciu kart inteligentnych lub wirtualnych kart inteligentnych, należy ustawić funkcję Certyfikaty udostępnionego użytkownika w pliku package.appxmanifest projektu WinUI lub projektu pakowania.

Dostęp do czytników połączonych kart i kart inteligentnych

Zapytania dotyczące czytników i dołączonych kart inteligentnych można wykonać, przekazując identyfikator urządzenia (określony w elemecie DeviceInformation) do metody SmartCardReader.FromIdAsync . Aby uzyskać dostęp do kart inteligentnych aktualnie dołączonych do zwróconego urządzenia czytnika, wywołaj metodę SmartCardReader.FindAllCardsAsync.

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();
}

Należy również umożliwić aplikacji obserwowanie zdarzeń CardAdded przez zaimplementowanie metody obsługi zachowania aplikacji podczas wstawiania karty.

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

Następnie można przekazać każdy zwrócony obiekt SmartCard do usługi SmartCardProvisioning , aby uzyskać dostęp do metod, które umożliwiają aplikacji dostęp i dostosowywanie jej konfiguracji.

Tworzenie wirtualnej karty inteligentnej

Aby utworzyć wirtualną kartę inteligentną przy użyciu funkcji SmartCardProvisioning, aplikacja najpierw będzie musiała podać przyjazną nazwę, klucz administratora i smartCardPinPolicy. Przyjazna nazwa jest ogólnie dostępna dla aplikacji, ale aplikacja nadal będzie musiała podać klucz administratora i wygenerować wystąpienie bieżącej klasy SmartCardPinPolicy przed przekazaniem wszystkich trzech wartości do requestVirtualSmartCardCreationAsync.

  1. Utwórz nowe wystąpienie SmartCardPinPolicy
  2. Wygeneruj wartość klucza administracyjnego, wywołując element CryptographicBuffer.GenerateRandom dla wartości klucza administracyjnego dostarczonej przez narzędzie usługi lub zarządzania.
  3. Przekaż te wartości wraz z ciągiem FriendlyNameText do elementu RequestVirtualSmartCardCreationAsync.
var pinPolicy = new SmartCardPinPolicy
    {
        MinLength = 6
    };

IBuffer adminkey = CryptographicBuffer.GenerateRandom(24);

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

Gdy element RequestVirtualSmartCardCreationAsync zwrócił skojarzony obiekt SmartCardProvisioning , wirtualna karta inteligentna jest aprowizowana i gotowa do użycia.

Uwaga / Notatka

Aby utworzyć wirtualną kartę inteligentną przy użyciu spakowanej aplikacji systemu Windows, użytkownik z uruchomioną aplikacją musi być członkiem grupy administratorów. Jeśli użytkownik nie jest członkiem grupy administratorów, tworzenie wirtualnej karty inteligentnej zakończy się niepowodzeniem.

Obsługa wyzwań związanych z uwierzytelnianiem

Aby uwierzytelnić się za pomocą kart inteligentnych lub wirtualnych kart inteligentnych, aplikacja musi zapewnić zachowanie, aby sprostać wyzwaniom między danymi klucza administracyjnego przechowywanymi na karcie, a danymi klucza administratora obsługiwanymi przez serwer uwierzytelniania lub narzędzie do zarządzania.

Uzyskiwanie klucza administratora

Przed przeprowadzeniem uwierzytelniania należy uzyskać klucz administratora. Źródło klucza administracyjnego zależy od twojego scenariusza:

  • W przypadku utworzonych wirtualnych kart inteligentnych: użyj tego samego klucza administratora, który został wygenerowany podczas tworzenia karty (jak pokazano w powyższej sekcji "Tworzenie wirtualnej karty inteligentnej"). Ten klucz należy przechowywać bezpiecznie do późniejszego użycia uwierzytelniania.
  • W przypadku istniejących kart inteligentnych fizycznych lub wirtualnych: klucz administracyjny jest zwykle dostarczany przez dział IT organizacji, system zarządzania kartami lub usługę, która wydała kartę.
  • W przypadku programowania/testowania: klucz administratora testu można wygenerować przy użyciu funkcji CryptographicBuffer.GenerateRandom , jak pokazano w poniższym przykładzie tworzenia karty wirtualnej.
// 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);

Przykładowe metody zarządzania kluczami administracyjnymi

Oto przykładowe metody, które można zaimplementować w celu bezpiecznego przechowywania i pobierania kluczy administracyjnych:

// 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);
}

Algorytm uwierzytelniania

Poniższy kod pokazuje, jak obsługiwać uwierzytelnianie kart inteligentnych dla usług lub modyfikacji szczegółów fizycznych lub wirtualnych kart. Jeśli dane wygenerowane przy użyciu klucza administratora na karcie ("wyzwanie") są takie same jak dane klucza administracyjnego dostarczone przez serwer lub narzędzie do zarządzania ("adminkey"), uwierzytelnianie zakończy się pomyślnie.

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;
    }
}

W ramach reszty tego tematu ten kod będzie wspomniany, gdy będziemy omawiać, jak przeprowadzić akcję uwierzytelniania oraz jak zastosować zmiany w informacjach o kartach inteligentnych i wirtualnych kartach inteligentnych.

Weryfikowanie odpowiedzi na uwierzytelnianie za pomocą karty inteligentnej lub wirtualnej karty inteligentnej

Po zdefiniowaniu logiki wyzwań związanych z uwierzytelnianiem możemy komunikować się z czytelnikiem w celu uzyskania dostępu do karty inteligentnej lub też uzyskać dostęp do wirtualnej karty inteligentnej na potrzeby uwierzytelniania.

  1. Aby rozpocząć wyzwanie, wywołaj metodę GetChallengeContextAsync z obiektu SmartCardProvisioning skojarzonego z kartą inteligentną. Spowoduje to wygenerowanie wystąpienia elementu SmartCardChallengeContext zawierającego wartość challenge karty.
  2. Następnie przekaż wartość wyzwania karty i klucz administracyjny dostarczony przez narzędzie usługi lub zarządzania do elementu ChallengeResponseAlgorithm zdefiniowanego w poprzednim przykładzie.
  3. Funkcja VerifyResponseAsync zwróci wartość true w przypadku pomyślnego uwierzytelnienia.
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);

Zmienianie lub resetowanie numeru PIN użytkownika

Aby zmienić numer PIN skojarzony z kartą inteligentną:

  1. Uzyskaj dostęp do karty i wygeneruj skojarzony obiekt SmartCardProvisioning .
  2. Wywołaj metodę RequestPinChangeAsync , aby wyświetlić użytkownikowi interfejs użytkownika w celu ukończenia tej operacji.
  3. Jeśli numer PIN został pomyślnie zmieniony, wywołanie zwróci wartość true.
SmartCardProvisioning provisioning =
    await SmartCardProvisioning.FromSmartCardAsync(card);

bool result = await provisioning.RequestPinChangeAsync();

Aby zażądać zresetowania numeru PIN:

  1. Wywołaj metodę RequestPinResetAsync , aby zainicjować operację. To wywołanie obejmuje metodę SmartCardPinResetHandler reprezentującą kartę inteligentną i żądanie resetowania numeru PIN.
  2. SmartCardPinResetHandler dostarcza informacji, które są wykorzystywane przez nasze ChallengeResponseAlgorithm, opakowane w wywołanie SmartCardPinResetDeferral, do porównania wartości wyzwania karty oraz klucza administracyjnego dostarczonego przez usługę lub narzędzie do zarządzania w celu uwierzytelnienia żądania.
  3. Jeśli zadanie zakończy się pomyślnie, wywołanie RequestPinResetAsync zostanie ukończone; zwraca wartość true , jeśli numer PIN został pomyślnie zresetowany.
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();
        }
    });
}

Usuwanie karty inteligentnej lub wirtualnej karty inteligentnej

Gdy fizyczna karta inteligentna zostanie usunięta, po usunięciu karty zostanie wyzwolone zdarzenie CardRemoved .

Powiąż wywołanie tego zdarzenia z czytnikiem kart przy pomocy metody, która definiuje zachowanie aplikacji w przypadku wyjęcia karty lub czytnika, jako obsługę zdarzenia. To zachowanie może być takie samo jak powiadomienie użytkownika, że karta została usunięta.

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

Usunięcie wirtualnej karty inteligentnej jest realizowane programowo poprzez najpierw pobranie karty, a następnie wywołanie metody RequestVirtualSmartCardDeletionAsync ze zwróconego obiektu SmartCardProvisioning.

bool result = await SmartCardProvisioning
    .RequestVirtualSmartCardDeletionAsync(card);

Treści powiązane

  • Last updated on