Weryfikacja podpisów w Javie – Weryfikowanie podpisów cyfrowych w Javie

Wprowadzenie

Czy kiedykolwiek otrzymałeś cyfrowo podpisany dokument i zastanawiałeś się, „Czy to naprawdę pochodzi od tego, za kogo się podaje?” Nie jesteś sam. Wraz ze wzrostem oszustw cyfrowych, java signature verification stało się kluczowe dla każdej aplikacji obsługującej wrażliwe dokumenty — niezależnie od tego, czy budujesz system zarządzania umowami, przetwarzasz umowy finansowe, czy weryfikujesz dokumenty rządowe.

Oto wyzwanie: wbudowana w Javę weryfikacja podpisów może być skomplikowana i ograniczona. Tu wkracza GroupDocs.Signature for Java. Upraszcza cały proces, jednocześnie dając potężne opcje, takie jak weryfikacja oparta na dacie i własne reguły walidacji.

W tym przewodniku dowiesz się dokładnie, jak:

  • Skonfigurować GroupDocs.Signature w projekcie Java
  • Weryfikować podpisy cyfrowe z własnymi opcjami i parametrami
  • Obsługiwać weryfikację zależną od daty dla dokumentów wrażliwych na czas
  • Unikać typowych pułapek, które mogą zagrozić bezpieczeństwu
  • Implementować walidację podpisów gotową do produkcji

Zacznijmy od tego, co będzie potrzebne, aby rozpocząć.

Szybkie odpowiedzi

  • Jaki jest najprostszy sposób weryfikacji podpisu PDF w Javie? Użyj Signature.verify() z obiektem VerificationOptions z GroupDocs.Signature.
  • Czy potrzebna jest licencja do produkcji? Tak — GroupDocs.Signature wymaga licencji komercyjnej lub tymczasowej do użytku produkcyjnego.
  • Czy mogę weryfikować podpisy starsze niż data wygaśnięcia certyfikatu? Tak — ustaw datę weryfikacji za pomocą VerificationOptions.setVerificationTime().
  • Ile formatów dokumentów jest obsługiwanych? Ponad 30 formatów, w tym PDF, DOCX, XLSX, PPTX i PNG.
  • Jaką wersję Javy zaleca się używać? Java 11+ dla najlepszych zabezpieczeń i wydajności.

Co to jest weryfikacja podpisu w Javie?

java signature verification to proces programistycznego potwierdzania, że cyfrowy podpis osadzony w dokumencie jest autentyczny, niezmieniony i został utworzony przez zaufanego podpisującego. Obejmuje kontrole kryptograficzne, walidację łańcucha certyfikatów oraz opcjonalną weryfikację opartą na czasie. Ten krok weryfikacji zapewnia tożsamość podpisującego i gwarantuje, że dokument nie został zmieniony od momentu podpisania.

Dlaczego weryfikacja podpisu cyfrowego ma znaczenie

Zanim przejdziemy do kodu, omówmy, dlaczego to ważne. Podpisy cyfrowe spełniają trzy krytyczne funkcje: potwierdzają autentyczność, gwarantują integralność i zapewniają nieodrzucalność. W praktyce oznacza to, że możesz ufać, że faktura naprawdę pochodzi od dostawcy, że umowa nie była manipulowana i że podpisana umowa ma moc prawną. Branże takie jak opieka zdrowotna (zgodność z HIPAA), finanse (wymagania SOX) i kontrakty rządowe polegają na tym codziennie.

Wymagania wstępne

Zanim zaczniemy, upewnij się, że masz:

  • Java Development Kit (JDK): wersja 8 lub wyższa (Java 11+ zalecane dla lepszych funkcji bezpieczeństwa)
  • IDE: IntelliJ IDEA, Eclipse lub VS Code z rozszerzeniami Java
  • Narzędzie budowania: Maven lub Gradle do zarządzania zależnościami
  • Podstawową wiedzę o Javie: zrozumienie klas, obiektów i operacji I/O

Nie musisz być ekspertem w kryptografii (na szczęście!), ale podstawowa znajomość podpisów cyfrowych pomaga. Jeśli dopiero zaczynasz, pomyśl o tym jak o wosku na kopercie — dowodzi, kto ją wysłał i czy ktoś ją otworzył.

Konfiguracja GroupDocs.Signature dla Javy

Zintegrujmy GroupDocs.Signature z Twoim projektem. Konfiguracja jest prosta, niezależnie od tego, czy używasz Maven, czy Gradle.

Konfiguracja Maven

Dodaj tę zależność do pliku pom.xml:

<dependency>
    <groupId>com.groupdocs</groupId>
    <artifactId>groupdocs-signature</artifactId>
    <version>23.12</version>
</dependency>

Konfiguracja Gradle

Dla użytkowników Gradle, umieść to w pliku build.gradle:

implementation 'com.groupdocs:groupdocs-signature:23.12'

Wskazówka: Zawsze sprawdzaj stronę wydań GroupDocs pod kątem najnowszej wersji. Nowsze wersje często zawierają poprawki bezpieczeństwa i usprawnienia wydajności.

Uzyskanie licencji

GroupDocs.Signature wymaga licencji do użytku produkcyjnego. Oto dostępne opcje:

  1. Bezpłatna wersja próbna: Idealna do testów i rozwoju (Pobierz tutaj)
  2. Licencja tymczasowa: Pełne funkcje na 30 dni (Zamów tutaj)
  3. Licencja komercyjna: Do wdrożeń produkcyjnych (Kup tutaj)

Bezpłatna wersja próbna ma pewne ograniczenia (np. znaki wodne), ale jest doskonała do nauki i prototypowania.

Podstawowa inicjalizacja

Po dodaniu zależności, tak wygląda inicjalizacja biblioteki:

Klasa Signature jest głównym punktem wejścia, który ładuje dokument i udostępnia metody podpisywania oraz weryfikacji.

import com.groupdocs.signature.Signature;

String filePath = "YOUR_DOCUMENT_DIRECTORY/sample_signed_document.pdf";
Signature signature = new Signature(filePath);

Weryfikacja podpisów cyfrowych: Podstawy

Teraz najciekawsza część. Krok po kroku weryfikujemy cyfrowo podpisany dokument.

Jaki jest pierwszy krok w weryfikacji podpisu w Javie?

Załaduj dokument przy pomocy instancji Signature i wywołaj verify() używając odpowiednio skonfigurowanego obiektu VerificationOptions. To pojedyncze wywołanie wykonuje walidację kryptograficzną, kontrole integralności i weryfikację łańcucha certyfikatów. Zapewnia autentyczność dokumentu oraz zaufanie do certyfikatu podpisującego w momencie weryfikacji.

Krok 1: Import wymaganych pakietów

Zacznij od zaimportowania potrzebnych klas:

Poniższe importy wprowadzają podstawowe klasy niezbędne do ładowania dokumentów, konfigurowania weryfikacji i obsługi wyników.

import com.groupdocs.signature.Signature;
import com.groupdocs.signature.domain.VerificationResult;
import com.groupdocs.signature.options.verify.DigitalVerifyOptions;

Krok 2: Konfiguracja opcji weryfikacji

Tutaj zaczyna się ciekawostka. Możesz dostosować proces weryfikacji przy użyciu konkretnych parametrów. Na przykład dodajmy komentarz, aby śledzić, dlaczego weryfikujemy ten dokument:

VerificationOptions definiuje kryteria i ustawienia używane podczas weryfikacji, takie jak które podpisy sprawdzać i jakie własne reguły walidacji zastosować.

DigitalVerifyOptions options = new DigitalVerifyOptions();
options.setComments("Approved");  // Tracks verification context

Dlaczego dodawać komentarze? To niezwykle przydatne w ścieżkach audytu. Gdy przeglądasz logi po sześciu miesiącach, od razu wiesz, dlaczego dokument został zweryfikowany i na jakiej podstawie.

Krok 3: Przeprowadzenie weryfikacji

Teraz wykonaj weryfikację:

VerificationResult zawiera wynik operacji weryfikacji, wskazując sukces lub porażkę oraz dostarczając szczegółowe informacje o napotkanych problemach.

VerificationResult result = signature.verify(options);
if (result.isValid()) {
    System.out.println("The document was verified successfully.");
} else {
    System.out.println("The document failed the verification process.");
}

VerificationResult to zwięzły obiekt, który informuje, czy podpis przeszedł wszystkie kontrole i podaje przyczyny niepowodzeń, gdy tak nie jest. Biblioteka sprawdza:

  • Czy podpis jest kryptograficznie ważny?
  • Czy dokument został zmodyfikowany po podpisaniu?
  • Czy łańcuch certyfikatów jest prawidłowy?

Jeśli wszystkie kontrole przejdą, otrzymasz true. W przeciwnym razie false — i dokument należy traktować jako podejrzany.

Obsługa weryfikacji zależnej od daty

Czasami trzeba zweryfikować, że podpis był ważny w określonym momencie. To kluczowe dla dokumentów prawnych, gdzie trzeba udowodnić „było to ważne 15 października 2024, nawet jeśli certyfikat wygasł później”.

Dlaczego obsługa dat ma znaczenie

Wyobraź sobie scenariusz: umowa została podpisana 1 czerwca, a certyfikat wygasł 1 lipca. Weryfikujesz ją 1 sierpnia. Bez obsługi dat weryfikacja nie powiedzie się, bo certyfikat jest nieważny. Dzięki weryfikacji opartej na dacie możesz potwierdzić, że była ważna w momencie podpisania — co ma znaczenie prawne.

Ustawianie daty weryfikacji

VerificationOptions.setVerificationTime() pozwala określić dokładny moment, względem którego ma być oceniana ważność certyfikatu.

import java.util.Date;
import java.text.SimpleDateFormat;

// Verify as if it's a specific date
SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
Date verificationDate = dateFormat.parse("2024-06-15");

options.setVerificationDate(verificationDate);

Wykonywanie weryfikacji opartej na dacie

Teraz uruchom weryfikację z parametrem daty:

Wywołanie verify() używa wcześniej ustawionego czasu weryfikacji, oceniając podpis tak, jakby był sprawdzany w tamtym historycznym momencie.

VerificationResult result = signature.verify(options);
if (result.isValid()) {
    System.out.println("The document was verified successfully for the specified date.");
} else {
    System.out.println("The document failed verification for that date.");
}

Przykład z życia: Instytucje finansowe używają tego przy audycie transakcji historycznych. Muszą potwierdzić, że podpisy były ważne w czasie podpisania, a nie tylko teraz.

Typowe błędy przy weryfikacji podpisów

Oszczędźmy Ci niepotrzebnych problemów. Oto najczęstsze pomyłki, które widziałem u deweloperów (i sam popełniłem, ucząc się tego):

1. Zapominanie o sprawdzeniu okresu ważności certyfikatu

Błąd: Zakładanie, że podpis jest nieważny, bo certyfikat wygasł.
Rozwiązanie: Zawsze używaj weryfikacji opartej na dacie dla dokumentów historycznych. Sprawdzaj, kiedy dokument został podpisany, a nie tylko, czy certyfikat jest ważny dziś.

2. Nieprawidłowe obsługiwanie ścieżek plików

Błąd: Hard‑kodowanie ścieżek, które psują się w różnych środowiskach.
Rozwiązanie:

Używaj Paths.get() do budowania ścieżek niezależnych od platformy i unikaj twardo zakodowanych separatorów.

// Don't do this:
String filePath = "C:\\Users\\John\\Documents\\contract.pdf";

// Do this instead:
String filePath = System.getProperty("user.dir") + "/documents/contract.pdf";
// Or use proper configuration files

3. Ignorowanie szczegółów wyniku weryfikacji

Błąd: Sprawdzanie jedynie isValid() bez analizowania dlaczego weryfikacja się nie powiodła.
Rozwiązanie:

Loguj result.getErrorMessage() i result.getErrorCode(), aby uzyskać szczegółowe przyczyny niepowodzenia.

VerificationResult result = signature.verify(options);
if (!result.isValid()) {
    // Get detailed failure information
    System.out.println("Verification failed. Details:");
    result.getFailed().forEach(signatureResult -> {
        System.out.println("Error: " + signatureResult.getMessage());
    });
}

4. Używanie niewłaściwych magazynów certyfikatów

Błąd: Niekonfigurowanie odpowiednich urzędów certyfikacji (CA) do walidacji.
Rozwiązanie: Upewnij się, że Twój keystore Javy zawiera certyfikaty główne dla Twojego organu podpisującego. To szczególnie ważne w środowiskach korporacyjnych z wewnętrznymi CA.

Najlepsze praktyki bezpieczeństwa

Weryfikacja jest tak bezpieczna, jak jej implementacja. Stosuj się do poniższych zaleceń, aby uniknąć podatności:

1. Zawsze weryfikuj przed zaufaniem

Nigdy nie zakładaj, że dokument jest bezpieczny. Weryfikacja powinna być obowiązkowym krokiem przed przetworzeniem jakiegokolwiek podpisanego pliku:

Signature.verify() zwraca wartość boolean wskazującą ogólną ważność podpisów w dokumencie.

public boolean processDocument(String filePath) {
    Signature signature = new Signature(filePath);
    DigitalVerifyOptions options = new DigitalVerifyOptions();
    
    // Mandatory verification check
    if (!signature.verify(options).isValid()) {
        throw new SecurityException("Document failed signature verification");
    }
    
    // Only proceed if verification passed
    return processVerifiedDocument(filePath);
}

2. Aktualizuj biblioteki

Luki bezpieczeństwa są regularnie naprawiane. Subskrybuj powiadomienia o bezpieczeństwie GroupDocs i aktualizuj natychmiast po wydaniu nowej wersji.

3. Używaj bezpiecznego przechowywania plików

Nie przechowuj zweryfikowanych dokumentów w publicznie dostępnych katalogach. Stosuj odpowiednie kontrole dostępu:

  • Ogranicz uprawnienia plików tylko do niezbędnych użytkowników
  • Używaj szyfrowanego magazynu dla wrażliwych dokumentów
  • Implementuj logowanie audytowe dla każdego dostępu do dokumentu

4. Waliduj łańcuchy certyfikatów

VerificationOptions może być skonfigurowane tak, aby wymuszać pełną walidację łańcucha aż do zaufanego urzędu nadrzędnego.

options.setVerifyCertificateChain(true);  // Ensures full chain validation

5. Ustaw odpowiednie limity czasowe

W środowisku produkcyjnym dodaj timeouty, aby zapobiec atakom DoS:

VerificationOptions.setTimeout(30_000) ustawia limit 30 sekund na operację weryfikacji.

// Prevent hanging on corrupted or malicious files
signature.setTimeoutMilliseconds(5000);  // 5-second timeout

Kiedy używać GroupDocs zamiast wbudowanych rozwiązań Javy

Możesz się zastanawiać: „Java ma wbudowaną weryfikację podpisów. Po co GroupDocs?”

Użyj wbudowanych API Javy, gdy:

  • Potrzebujesz jedynie podstawowej weryfikacji podpisu
  • Pracujesz wyłącznie z konkretnymi formatami (np. podpisy JAR)
  • Chcesz zerowej liczby zewnętrznych zależności
  • Masz wewnętrzną ekspertyzę kryptograficzną

Użyj GroupDocs.Signature, gdy:

  • Musisz weryfikować wiele formatów dokumentów (PDF, DOCX, XLSX itp.)
  • Chcesz uproszczone, wysokopoziomowe API
  • Potrzebujesz zaawansowanych funkcji, takich jak weryfikacja oparta na dacie
  • Pracujesz z kodami QR, kodami kreskowymi lub podpisami w metadanych
  • Szybkość rozwoju jest ważniejsza niż liczba zależności

Podsumowanie: GroupDocs.Signature to jak posiadanie specjalisty od weryfikacji podpisów w zespole. Można to zbudować samodzielnie przy użyciu niskopoziomowych API, ale po co tracić tygodnie, gdy można to zrobić w kilka dni?

Rozwiązywanie typowych problemów

Masz problemy? Oto rozwiązania najczęstszych trudności:

Problem: wyjątek „File not found”

Objawy: FileNotFoundException mimo że plik istnieje.

Rozwiązania:

  1. Sprawdź format ścieżki (używaj ukośników lub podwójnych backslashów)
  2. Zweryfikuj uprawnienia pliku — czy aplikacja może go odczytać?
  3. Podczas debugowania używaj ścieżek bezwzględnych, aby wyeliminować problemy ze ścieżkami

Path.of() tworzy obiekt ścieżki niezależny od platformy, redukując błędy związane ze ścieżkami.

// Debug file path issues
File file = new File(filePath);
System.out.println("File exists: " + file.exists());
System.out.println("Can read: " + file.canRead());
System.out.println("Absolute path: " + file.getAbsolutePath());

Problem: weryfikacja nie przechodzi pomimo prawidłowego podpisu

Objawy: Wiesz, że podpis jest ważny, ale weryfikacja zwraca false.

Rozwiązania:

  1. Sprawdź, czy certyfikat nie wygasł (użyj weryfikacji opartej na dacie dla dokumentów historycznych)
  2. Upewnij się, że Twój keystore Javy zawiera root CA podpisującego
  3. Zweryfikuj, czy dokument nie został zmodyfikowany po podpisaniu (nawet drobne zmiany łamią podpis)
  4. Sprawdź, czy używany algorytm jest obsługiwany przez Twoją wersję Javy

Problem: błędy OutOfMemory przy dużych plikach

Objawy: OutOfMemoryError podczas weryfikacji dużych PDF‑ów lub partii dokumentów.

Rozwiązania:

  1. Zwiększ rozmiar stosu JVM: -Xmx2g (lub więcej, w zależności od potrzeb)
  2. Przetwarzaj pliki pojedynczo, zamiast ładować je wszystkie naraz
  3. Używaj weryfikacji strumieniowej dla bardzo dużych plików

Signature.verifyStream() przetwarza dokument w kawałkach, utrzymując niskie zużycie pamięci.

// Proper resource management
try (Signature signature = new Signature(filePath)) {
    VerificationResult result = signature.verify(options);
    // Process result
} // Automatically closes and releases resources

Problem: wolna wydajność weryfikacji

Objawy: Weryfikacja zajmuje kilka sekund na dokument.

Rozwiązania:

  1. Cache’uj wyniki walidacji certyfikatów przy weryfikacji wielu dokumentów od tego samego podpisującego
  2. Wykorzystaj przetwarzanie równoległe przy weryfikacji partii
  3. Wyłącz niepotrzebne opcje weryfikacji
  4. Sprawdź opóźnienia sieciowe, jeśli weryfikujesz przeciwko zdalnym magazynom certyfikatów

Zaawansowane wskazówki dla środowisk produkcyjnych

Gotowy na produkcję? Oto kilka profesjonalnych rad:

1. Implementuj kompleksowe logowanie

Loguj nie tylko sukces lub porażkę — loguj wszystko, co przydatne do debugowania:

logger.info("Verification result: {}", result) zapisuje pełny obiekt wyniku do późniejszej analizy.

import java.util.logging.Logger;

Logger logger = Logger.getLogger(YourClass.class.getName());

VerificationResult result = signature.verify(options);
logger.info(String.format(
    "Verification for %s: %s (Processed in %dms)",
    filePath,
    result.isValid() ? "PASSED" : "FAILED",
    result.getProcessingTime()
));

if (!result.isValid()) {
    result.getFailed().forEach(failure ->
        logger.warning("Verification failure: " + failure.getMessage())
    );
}

2. Używaj asynchronicznej weryfikacji dla większej przepustowości

Przy przetwarzaniu wielu dokumentów, zastosuj asynchroniczne przetwarzanie:

CompletableFuture.runAsync(() -> signature.verify(options)) uruchamia weryfikację w osobnym wątku.

import java.util.concurrent.CompletableFuture;

public CompletableFuture<VerificationResult> verifyAsync(String filePath) {
    return CompletableFuture.supplyAsync(() -> {
        try (Signature signature = new Signature(filePath)) {
            return signature.verify(options);
        }
    });
}

3. Wdroż circuit breakerów dla zależności zewnętrznych

Jeśli weryfikacja zależy od zewnętrznych usług walidacji certyfikatów, użyj circuit breakerów, aby radzić sobie z awariami.

4. Cache’uj wyniki weryfikacji (z rozwagą)

Dla niezmiennych dokumentów możesz cache’ować wyniki, ale pamiętaj o prawidłowym odświeżaniu cache’u:

Cache.put(docId, result, Duration.ofHours(24)) przechowuje wynik przez dzień.

// Pseudocode for caching strategy
String cacheKey = filePath + "_" + fileChecksum;
if (verificationCache.containsKey(cacheKey)) {
    return verificationCache.get(cacheKey);
}
// Verify and cache
VerificationResult result = signature.verify(options);
verificationCache.put(cacheKey, result, CACHE_TTL);

5. Monitoruj i alarmuj przy niepowodzeniach weryfikacji

Śledź wskaźniki niepowodzeń weryfikacji. Nagły wzrost może wskazywać na:

  • Zainfekowane dokumenty w systemie
  • Wygasające certyfikaty wymagające odnowienia
  • Problemy konfiguracyjne po wdrożeniu

Praktyczne zastosowania i przypadki użycia

Spójrzmy, jak to działa w rzeczywistych scenariuszach:

Przypadek użycia 1: System zarządzania umowami

Scenariusz: Kancelaria potrzebuje weryfikować wszystkie przychodzące umowy pod kątem prawidłowego podpisu.

Implementacja: Signature signature = new Signature(contractFile); VerificationResult result = signature.verify(new VerificationOptions());

public boolean processIncomingContract(String contractPath) {
    try (Signature signature = new Signature(contractPath)) {
        DigitalVerifyOptions options = new DigitalVerifyOptions();
        options.setComments("Contract intake verification");
        
        VerificationResult result = signature.verify(options);
        
        if (result.isValid()) {
            // Move to approved contracts folder
            // Trigger workflow for legal review
            return true;
        } else {
            // Flag for manual review
            // Notify sender of invalid signature
            return false;
        }
    }
}

Przypadek użycia 2: Audyt dokumentów finansowych

Scenariusz: Bank musi zweryfikować historyczne umowy pożyczkowe podczas audytu regulacyjnego.

Implementacja: Użyj weryfikacji opartej na dacie, aby potwierdzić, że podpisy były ważne w momencie podpisania, nawet jeśli certyfikaty wygasły później.

Przypadek użycia 3: Walidacja dokumentów wielostronnych

Scenariusz: Transakcja nieruchomości wymaga weryfikacji podpisów kupującego, sprzedającego i agenta.

Implementacja: Zweryfikuj każdy podpis osobno i wymagaj, aby wszystkie trzy przeszły pomyślnie przed finalizacją transakcji.

Rozważania dotyczące wydajności

Przy przetwarzaniu tysięcy dokumentów wydajność ma znaczenie. Oto czynniki wpływające na szybkość:

Czynniki wpływające na wydajność

  1. Rozmiar dokumentu: Większe pliki trwają dłużej
  2. Liczba podpisów: Każdy podpis dodaje czas przetwarzania
  3. Długość łańcucha certyfikatów: Dłuższe łańcuchy wymagają więcej kroków walidacji
  4. Dostęp sieciowy: Zdalna walidacja certyfikatów zwiększa opóźnienia

Strategie optymalizacji

  • Przetwarzanie wsadowe: Weryfikuj wiele dokumentów równolegle
  • Lokalne cache’owanie certyfikatów: Unikaj powtarzających się wywołań sieciowych
  • Selektywna weryfikacja: Weryfikuj tylko to, co jest niezbędne w danym scenariuszu
  • Pula zasobów: Re‑używaj obiektów Signature, gdy to możliwe (sprawdź dokumentację pod kątem bezpieczeństwa wątkowego)

ExecutorService może zarządzać pulą wątków do równoczesnej weryfikacji dokumentów, zwiększając przepustowość.

// Example: Batch verification with parallel streams
List<String> filePaths = Arrays.asList("doc1.pdf", "doc2.pdf", "doc3.pdf");

Map<String, Boolean> results = filePaths.parallelStream()
    .collect(Collectors.toMap(
        path -> path,
        path -> {
            try (Signature sig = new Signature(path)) {
                return sig.verify(options).isValid();
            }
        }
    ));

Najczęściej zadawane pytania

P: Czym różni się podpis cyfrowy od podpisu elektronicznego?
O: Podpis cyfrowy wykorzystuje algorytmy kryptograficzne do potwierdzenia autentyczności i wykrycia manipulacji. Podpis elektroniczny jest szerszym pojęciem — każdy elektroniczny sygnał intencji (np. wpisane imię) może być uznany za podpis. Podpisy cyfrowe są konkretnym, bardziej bezpiecznym rodzajem podpisu elektronicznego.

P: Jak zainstalować GroupDocs.Signature dla Javy?
O: Dodaj go jako zależność Maven lub Gradle (zobacz sekcję konfiguracji), albo pobierz JAR‑a bezpośrednio ze strony GroupDocs i dodaj go do classpath projektu.

P: Czy mogę weryfikować podpisy bez licencji GroupDocs?
O: Tak, możesz korzystać z wersji próbnej do rozwoju i testów. Ma ona pewne ograniczenia (np. znaki wodne), ale wystarcza do nauki. Do produkcji potrzebna jest licencja komercyjna lub tymczasowa.

P: Co się dzieje, gdy weryfikacja nie powiedzie się?
O: Metoda verify() zwraca obiekt VerificationResult z isValid() ustawionym na false. Możesz przejrzeć szczegóły wyniku, aby dowiedzieć się, dlaczego — wygasły certyfikat, modyfikacja dokumentu, nieobsługiwany algorytm itp.

P: Jak obsługa dat poprawia weryfikację podpisu?
O: Pozwala zweryfikować, że podpis był ważny w określonym momencie, co jest kluczowe w kontekstach prawnych i audytowych. Bez tego możesz sprawdzić tylko aktualną ważność, co nie wystarcza dla dokumentów historycznych z wygasłymi certyfikatami.

P: Czy mogę weryfikować wiele typów podpisów w jednym dokumencie?
O: Oczywiście. Dokumenty PDF mogą zawierać wiele cyfrowych podpisów od różnych podpisujących. Weryfikuj każdy z osobna, używając tego samego obiektu Signature i różnych opcji weryfikacji, jeśli to konieczne.

P: Czy GroupDocs.Signature jest bezpieczny w środowiskach wielowątkowych?
O: Sprawdź najnowszą dokumentację pod kątem gwarancji bezpieczeństwa wątkowego, ale najbezpieczniej jest tworzyć osobną instancję Signature dla każdego wątku przy przetwarzaniu partii.

P: Jakie formaty dokumentów są obsługiwane?
O: PDF, formaty Microsoft Office (DOCX, XLSX, PPTX), obrazy i wiele innych. Pełną listę znajdziesz w dokumentacji.

Dodatkowe zasoby

Ostatnia aktualizacja: 2026-07-01
Testowane z: GroupDocs.Signature 23.12 for Java
Autor: GroupDocs

Powiązane samouczki