Teknik Makale

ISO/TS 32002 ECDSA ve EdDSA Denetimleri, PDFium Delphi

Bir P-256 anahtarı bir SHA-512 digesti imzalayabilir ve matematik itiraz etmez. ECDSA, hashi en anlamlı 256 bite kırpar, imza doğrulanır ve bir CMS doğrulayıcı imza değerini sapasağlam bildirir. ISO/TS 32002 - eliptik eğri ve EdDSA imzalarını PDFe taşıyan PDF 2.0 uzantısı - o eşlemeye izin vermez; çünkü her eğriyi taşıyabileceği digest genişliklerine bağlar. Aynı imzalı fatura bu yüzden bir makinede kriptografik kontrolü geçerken, PDF 2.0 algoritma profilini uygulayan bir doğrulayıcıda düşer ve iki hüküm de kendi sorduğu soruda haklıdır

ISO/TS 32002 hangi eğri ve digest çiftlerini kabul eder

ISO/TS 32002, altı ECDSA eğrisi ve iki EdDSA şeması kabul eder. PDFium Component her PDF imzasını o profile karşı denetler ve hükmünü TPadesSignatureValidation.AlgorithmPolicyStatuste bildirir; imzalayan sertifikasındaki eğri OIDine göre anahtarlanır. NIST eğrileri katıdır: digest, eğriyle aynı bit genişliğinde olmalıdır; SHA-2 ya da SHA-3 ailesinden. Brainpool r1 eğrileri daha esnektir ve kendi genişliklerini ya da her şeyden genişi kabul eder:

  • P-256 (1.2.840.10045.3.1.7): yalnızca SHA-256 ya da SHA3-256
  • P-384 (1.3.132.0.34): yalnızca SHA-384 ya da SHA3-384
  • P-521 (1.3.132.0.35): yalnızca SHA-512 ya da SHA3-512
  • brainpoolP256r1 (1.3.36.3.3.2.8.1.1.7): 256 ile 512 bit arası herhangi bir SHA-2 ya da SHA-3 digest
  • brainpoolP384r1 (1.3.36.3.3.2.8.1.1.11): 384 ya da 512 bitlik SHA-2 / SHA-3
  • brainpoolP512r1 (1.3.36.3.3.2.8.1.1.13): yalnızca SHA-512 ya da SHA3-512
PDFium Component'te ISO TS 32002 algoritma profili matrisi: P-256, P-384 ve P-521 yalnızca eşleşen digest genişliklerini kabul eder; brainpoolP256r1 256-512 biti, brainpoolP384r1 384 ve 512'yi kabul eder; Ed25519 ile Ed448, 512 uzunluklu SHA-512 ve SHAKE256 bildirir; uyuşmazlıklar ppeiSignatureAlgorithmMismatch yükseltirken profil dışı eğriler pcsUnsupported döndürür
Altı ECDSA eğrisi ve iki EdDSA şeması geçebilir ve her eğri taşıyabileceği digest genişliklerine bağlıdır; gerisi geçersiz ya da desteklenmezdir, asla sessizce kabul edilmez

Asimetri, tek bir digest seçip her anahtar için onu kullanan imzalama araçlarını yakalar. Her yerde SHA-512 temkinli seçim gibi görünür ve brainpoolP256r1 üzerinde kabul edilir. P-256da aynı yapılandırma pcsInvalid üretir: eğri profilin içinde, digest güçlü ve eşleme yine de tablonun dışında. Profilin hiç adını vermediği bir eğrideki anahtar - brainpoolP160r1 (1.3.36.3.3.2.8.1.1.1) ya da secp256k1 (1.3.132.0.10) gibi - başka bir kovaya düşer. Bildirdiği digest ile imza algoritması uyuştuğu sürece pcsUnsupported alır

EdDSA seçenek bırakmaz; yalnızca kodlama kuralları vardır

Ed25519 ile Ed448in eğri parametresi ve digest seçeneği yoktur; PDFium Componentin onlara uyguladığı her kural, CMSin algoritmayı nasıl bildirdiğiyle ilgilidir. Digesti RFC 8419 sabitler. Bir Ed25519 SignerInfo, digestAlgorithm olarak SHA-512yi (2.16.840.1.101.3.4.2.3), parameters alanı hiç olmadan bildirir. İmzalı öznitelikler taşıyan bir Ed448 SignerInfo - her PAdES imzası taşır - id-shake256-leni (2.16.840.1.101.3.4.2.18), tam 512 değerinde bir INTEGER parametresiyle bildirir. RFC 8410 ise imza AlgorithmIdentifierının (Ed25519 için 1.3.101.112, Ed448 için 1.3.101.113) ve sertifika genel anahtarı AlgorithmIdentifierının hiç parametre taşımadığını ekler

Pek çok ASN.1 kodlayıcı, RSA tanımlayıcılarının baştan beri bir tane taşıması yüzünden her algoritma OIDine açık bir NULL ekler ve alışkanlık, biri Ed25519u mevcut bir imzalama yoluna eklediğinde de yaşar. Anahtar sağlamdır. İmza değeri sağlamdır. Kodlama bozuktur ve PDFium Component, iki tanımlayıcıdan birinde parameters alanı varken, Ed25519 digesti parameterssız SHA-512den başka bir şeyken ya da Ed448 digesti 512li id-shake256-len değilken pcsInvalid döndürür. Anahtar OIDi öbür EdDSA şemasına ya da başka bir algoritmaya ait bir sertifika da pcsInvalid verir

Algoritma üçlüsünü CMSden okumak

PDFium motoru imza sözlüğünü okur ama genel APIsi ne CMSi doğrular ne de imzalayan sertifikasının eğrisini açar. Bu yüzden PDFium üzerine kurulu PAdES inceleme katmanı, CMS SignedDatayı (RFC 5652) kendisi ayrıştırır. InspectPadesSignatureAlgorithm, ilk SignerInfonun digestAlgorithm ile signatureAlgorithmını okur, imzalayan sertifikasını certificates kümesinde bulur ve anahtar algoritması ile eğriyi SubjectPublicKeyInfosundan okur. Digest, imza algoritması, anahtar artı eğri: politikanın yargıladığı üç değer bunlardır

Bir CMS sertifika kümesi sırasızdır ve çoğu zaman imzalayan sertifikasını onu imzalayan CAın yanı sıra taşır; ikisi de farklı eğrilerde EC anahtarları olabilir. İlk EC sertifikasını almak, CAın imzalayanın hangi eğriyi kullandığına karar vermesine yol açardı. PDFium Component, issuerAndSerialNumberdaki issuer ile seri numarasını bayt bayt eşler, en çok 64 sertifikaya bakar ve "içinde tek sertifika var" yoluna yalnızca kümede tam olarak tek ayrıştırılabilir sertifika olduğunda gider. Başka her sonuç, kaydın anahtar alanlarını boş bırakır

PDFium Component bir PDF imza algoritma üçlüsünü nasıl inceler: InspectPadesSignatureAlgorithm, CMS'teki ilk SignerInfo'nun digestAlgorithm ile signatureAlgorithm'ını okur; imzalayan sertifikasını en çok 64 aday arasından tam issuerAndSerialNumber eşleşmesiyle sabitler; eğri için SubjectPublicKeyInfo'yu okur ve EvaluatePadesSignatureAlgorithm, AlgorithmPolicyStatus'u döndürür
PDFium kendi başına CMS'i doğrulamaz ne de imzalayan eğrisini açar; PAdES katmanı bu yüzden SignedData'yı ayrıştırır ve her ham OID'i, açıklanabilir bir red için kayıtta saklar

TPdf.ValidatePades, politikayı uyumluluk geçişi sırasında çalıştırır; önce CMSin içinde bulunan sertifikaya karşı. Ardından imzayı platformun CMS doğrulayıcısıyla doğrular: Windowsda varsayılan olarak Windows CryptoAPI, ya da ConfigureSslCmsVerifier ya da ConfigureKeychainCmsVerifier ile kaydedilmiş bir OpenSSL ya da macOS Keychain doğrulayıcısı. Doğrulayıcı hangi sertifikayı gerçekten kullandığını bildirdiğinde politika o sertifikada bir kez daha çalışır ve sonucu ilkinin yerini alır. Enterprise sürümündeki TPdf.ValidatePadesTrust aynı sırayı izler; üstelik zinciri kurar ve istenirse iptali denetler. Ham girdiler TPadesSignatureAlgorithmInfoda birikir; bu döküm, bir dosyadaki her imza için onu yazdırır:

uses
  PDFium, FPdfPades;

const
  StatusNames: array[TPadesCryptoStatus] of string =
    ('not checked', 'valid', 'invalid', 'unsupported', 'indeterminate');

var
  Pdf: TPdf;
  R: TPadesValidationResult;
  A: TPadesSignatureAlgorithmInfo;
  I: Integer;
begin
  Pdf := TPdf.Create(nil);
  try
    Pdf.FileName := 'invoice-ecdsa-signed.pdf';
    Pdf.Active := True;
    R := Pdf.ValidatePades;
    for I := 0 to Length(R.Signatures) - 1 do
    begin
      A := R.Signatures[I].AlgorithmInfo;
      Writeln('Signature ', I);
      Writeln('  digestAlgorithm    : ', string(A.DigestAlgorithmOid),
        '  params=', A.DigestParametersPresent, ' bits=', A.DigestParameterBits);
      Writeln('  signatureAlgorithm : ', string(A.SignatureAlgorithmOid),
        '  params=', A.SignatureParametersPresent);
      Writeln('  public key / curve : ', string(A.PublicKeyAlgorithmOid),
        ' / ', string(A.CurveOid),
        '  namedCurve=', A.PublicKeyParametersAreNamedCurve);
      Writeln('  policy             : ',
        StatusNames[R.Signatures[I].AlgorithmPolicyStatus]);
    end;
    if ppeiSignatureAlgorithmMismatch in R.Issues then
      Writeln('At least one signature violates the ISO/TS 32002 profile');
  finally
    Pdf.Free;
  end;
end;

O bayraklar, kimse ASN.1 dökümü açmadan bir reddi genellikle açıklar. DigestParameterBits, Ed448 uzunluğunu gösterir; SignatureParametersPresent, başıboş NULLu ortaya çıkarır; PublicKeyParametersAreNamedCurve, bir sonraki bölümde konuşulan eğri kodlamasını kapsar. Boş bir PublicKeyAlgorithmOid, imzalayan sertifikasının hiç sabitlenemediği demektir

P-256 ile SHA3-256 imzası politikayı neden düşürür?

SHA3-256lı bir P-256 imzası, CMS digestAlgorithmi SHA3-256 derken signatureAlgorithm ecdsa-with-SHA256 dediğinde düşer. Her yarı tek başına P-256 için kabul edilebilir; birlikte hangi hashin imzalandığı konusunda anlaşamazlar. EvaluatePadesSignatureAlgorithm, her ECDSA imza OIDini - ecdsa-with-SHA256den ecdsa-with-SHA3-512e - ima ettiği digeste eşler, bunu bildirilen digestAlgorithmle karşılaştırır ve eğri tablosuna bakmadan her farkta pcsInvalid döndürür. Hashini SHA3-256ye taşıyıp sert kodlanmış imza tanımlayıcısını tutan bir imzalama aracı tam bu dosyayı üretir ve uyumlu bir doğrulayıcının onu tutarlı okumasının yolu yoktur

EvaluatePadesSignatureAlgorithm genel erişimlidir ve düz bir kayıt alır; dolayısıyla matris, PDF kurmadan bir unit testte sabitlenebilir. Aşağıdaki Assert çağrıları kendi test kontrollerinizdir:

var
  Info: TPadesSignatureAlgorithmInfo;
begin
  Info := Default(TPadesSignatureAlgorithmInfo);
  Info.Family := psafEcdsa;
  Info.PublicKeyAlgorithmOid := '1.2.840.10045.2.1';       // id-ecPublicKey
  Info.PublicKeyParametersPresent := True;
  Info.PublicKeyParametersAreNamedCurve := True;
  Info.CurveOid := '1.2.840.10045.3.1.7';                  // P-256
  Info.DigestAlgorithmOid := '2.16.840.1.101.3.4.2.8';     // SHA3-256
  Info.SignatureAlgorithmOid := '2.16.840.1.101.3.4.3.10'; // ecdsa-with-SHA3-256
  Assert(EvaluatePadesSignatureAlgorithm(Info) = pcsValid);

  Info.SignatureAlgorithmOid := '1.2.840.10045.4.3.2';     // ecdsa-with-SHA256
  Assert(EvaluatePadesSignatureAlgorithm(Info) = pcsInvalid);  // digest uyuşmazlığı

  Info.DigestAlgorithmOid := '2.16.840.1.101.3.4.2.3';     // SHA-512
  Info.SignatureAlgorithmOid := '1.2.840.10045.4.3.4';     // ecdsa-with-SHA512
  Assert(EvaluatePadesSignatureAlgorithm(Info) = pcsInvalid);  // uyumlu ama P-256 için değil

  Info.CurveOid := '1.3.36.3.3.2.8.1.1.1';                 // brainpoolP160r1
  Assert(EvaluatePadesSignatureAlgorithm(Info) = pcsUnsupported); // eğri profilin dışında

  Info.CurveOid := '1.2.840.10045.3.1.7';
  Info.PublicKeyParametersAreNamedCurve := False;          // açık eğri parametreleri
  Assert(EvaluatePadesSignatureAlgorithm(Info) = pcsInvalid);

  Info.PublicKeyAlgorithmOid := '';                        // imzalayan sertifikası bulunamadı
  Assert(EvaluatePadesSignatureAlgorithm(Info) = pcsIndeterminate);
end;

Beşinci durum, sertifikanın eğrisini nasıl kodladığıyladır. RFC 5480 §2.1.1, ECParametersin adlandırılmış bir eğri OIDi, örtük bir eğri (NULL) ya da eksiksiz bir açık parametre kümesi olmasına izin verir ve aynı bölüm, PKIX sertifikalarını adlandırılmış biçimle sınırlar. PDFium Component, parametresiz, örtük ya da açık parametreli bir id-ecPublicKey sertifikası için pcsInvalid döndürür. Açık parametreler asalı, katsayıları ve taban noktası yazar; bu da bir saldırganın yalnızca standart bir eğriye benzeyen bir eğri anlatmasına izin verir. Onları kabul eden bir denetçinin, başka hiçbir şeye güvenmeden önce sayıların adlandırılmış bir eğriyle eşleştiğini kanıtlaması gerekirdi

Invalid, unsupported ve indeterminate üç farklı cevaptır

AlgorithmPolicyStatusin üç geçersiz-olmayan değeri farklı şeyler taşır ve onları tek bir "başarısız" kovaya dökmek, denetçinin ihtiyaç duyduğu bilgiyi çöpe atar. pcsInvalid, tanınan bir algoritma kombinasyonunun bozuk ya da uyumsuz olduğu demektir. TPadesValidationResult.Issuese ppeiSignatureAlgorithmMismatch ekler ve toplam IntegrityStatusu pcsInvalide çeker; böylece CMS imza değeri doğru çıksa bile IsCryptographicallyValid False döndürür

pcsUnsupported, eğri ya da digestin profilin adlandırdığı şeylerin dışında olduğu demektir. Bu bir yetenek sonucudur ve IntegrityStatuse dokunmaz. pcsIndeterminate, PDFium Componentin tahmin etmeyi reddettiği demektir: imzalayan sertifikası sabitlenemedi - genellikle birkaç adaylı bir sertifika kümesinde tam bir issuerAndSerialNumber eşleşmesi yoktur - ya da SignerInfo, algoritmalarını okunacak kadar ayrıştırılamadı. RSA tarafında aynı değer, güncel takımların yeni doğrulamalar için artık kabul etmediği bir digesti işaretler; son bölümde bu var

EdDSA, politika durumuyla kriptografik durumun neden ayrı alanlarda yaşadığını gösterir. CMS doğrulayıcısı Ed25519 ya da Ed448i denetleyemeyen bir sistemde CmsSignatureStatus pcsUnsupported dönerken AlgorithmPolicyStatus, CMSde bulunan sertifikadan hesaplanarak pcsValid olabilir. Kodlama doğruydu; eksik olan yalnızca doğrulayıcıyd. İkisini birleştirmek, kusursuz biçimli bir imzaya bozuk demeye ya da denetlenmemiş birine sağlam demeye zorlardı

PDFium Component'te EvaluatePadesSignatureAlgorithm karar yolu: digest uyuşmazlığı pcsInvalid ile ppeiSignatureAlgorithmMismatch kurar; brainpoolP160r1 gibi ISO TS 32002 profili dışında adlandırılmış bir eğri pcsUnsupported kurar; tespit edilemeyen imzalayan sertifikası pcsIndeterminate kurar; RSA dalı ETSI TS 119 312 digest takımlarını uygular, anahtar boyutu hâlâ uygulamaya kalır
Geçerli olmayan üç durum farklı şeyler demektir: invalid bozuk kombinasyonun kanıtıdır, unsupported bir yetenek sonucudur, indeterminate ise kodun tahmin etmeyi reddettiği anlamına gelir

Antreye giren bir işlem hattı için otomatik red yalnızca pcsInvalidde olsun. pcsUnsupportedi red saymak, politikanızın hiç listelemediği bir eğriyi kurcalama suçlamasına çevirir ve gönderen, hiç bozulmamış olan bir şeyi düzeltmenin yolunu bulamaz. Unsupported ile indeterminate sonuçları, AlgorithmInfodaki OIDler ekli olarak bir insana yönlendirin:

var
  Pdf: TPdf;
  Options: TPadesTrustValidationOptions;
  R: TPadesValidationResult;
  S: TPadesSignatureValidation;
  I: Integer;
begin
  Pdf := TPdf.Create(nil);
  try
    Pdf.FileName := 'invoice-ecdsa-signed.pdf';
    Pdf.Active := True;
    Options := TPadesTrustValidationOptions.Default; // çevrimdışı, iptal denetimi yok
    R := Pdf.ValidatePadesTrust(Options);
    for I := 0 to Length(R.Signatures) - 1 do
    begin
      S := R.Signatures[I];
      if S.IsDocumentTimeStamp then
        Continue;
      case S.AlgorithmPolicyStatus of
        pcsInvalid:       Writeln(I, ': reject, algorithm combination is invalid');
        pcsUnsupported:   Writeln(I, ': manual review, algorithm outside the profile: ',
                            string(S.AlgorithmInfo.SignatureAlgorithmOid), ' / ',
                            string(S.AlgorithmInfo.CurveOid));
        pcsIndeterminate: Writeln(I, ': manual review, signer not identified or digest no longer accepted');
        pcsValid:
          if S.AlgorithmInfo.Family = psafRsa then
            Writeln(I, ': RSA digest suite accepted, check key size yourself')
          else
            Writeln(I, ': EC/EdDSA profile satisfied');
      end;
      if (S.CmsSignatureStatus = pcsUnsupported) and
         (S.AlgorithmPolicyStatus = pcsValid) then
        Writeln(I, ': encoding conforms, but no verifier here can check this algorithm');
    end;
    Writeln('Cryptographically valid: ', R.IsCryptographicallyValid);
  finally
    Pdf.Free;
  end;
end;

Red, bu kontrolden değil Adobe Acrobat ya da DSS tabanlı bir doğrulayıcıdan geliyorsa, doğrulayıcıların PAdES imzalarını neden reddettiği rehberi, ByteRange boşluklarından bozuk bir /M imzalama zamanına kadar öbür olağan nedenleri gezer

pcsValid gerisini size bırakır

AlgorithmPolicyStatus = pcsValid, algoritma profilini sertifikalandırır ve daha fazlasını değil: ECDSA ile EdDSA için eşleşen, doğru kodlanmış digestli onaylı bir eğri ya da RSA için güncel bir takımın digesti. RSA imzalarında EvaluatePadesSignatureAlgorithm, ETSI TS 119 312 takımlarını uygular. MD2, MD4 ve MD5 pcsInvaliddir. SHA-1 ile 112 bitlik digestler (SHA-224, SHA-512/224, SHA3-224) pcsIndeterminatedir - algoritmanın artık güvenilir sayılmadığı ve daha önce var olma kanıtının değerlendirilmediği durumda EN 319 102-1in kullandığı sonuç budur; dolayısıyla SHA-1 imza bütünlük sonucunu korur ve incelemeye gider. İmza OIDinin sabitlediği digestten farklı bir digestAlgorithm - SHA-1 digest üzerinden sha256WithRSAEncryption gibi - pcsInvaliddir; RSA olmayan bir imzalayan anahtarındaki RSA imza algoritması da öyledir. Bulunamayan bir imzalayan sertifikası pcsIndeterminate verir; bilinmeyen digestler ile PKCS #1 kolundan imza olmayan OIDler pcsUnsupported verir

RSASSA-PSS imzaları bir de parametre kontrolü alır: PSS parametreleri var olmalı ve kusursuz kurulu olmalı, hashleri bildirilen digestAlgorithme eşit olmalı, trailer alanı 1 olmalı ve PSSye kısıtlanmış bir sertifika anahtarı onlarla aynı fikirde olmalıdır. RFC 4055 RSASSA-PSS-params yazısı, o parametrelerin imzalama tarafında nasıl kodlandığını anlatır. Modül uzunluğu politikanın dışındadır; 3072 bitlik bir taban isteyen uygulama onu kendisi uygular. digestAlgorithmdeki SHA-1 ya da MD5 ayrıca ayrı bir ppeiBadDigestAlgorithm sorunu yükseltir. İmzalı öznitelikler RFC 6211in cms-algorithm-protection özniteliğini taşıdığında, iki tanımlayıcısı SignerInfo değerleriyle bayt bayt karşılaştırılır; bir fark ppeiCmsAlgorithmProtectionMismatch yükseltir ve bütünlüğü düşürür. VerifyCmsAlgorithmProtection o karşılaştırmayı ham bir CMS blobu üzerinde çalıştırır

İmza matematiği, sertifika zinciri ve iptal, CMS doğrulayıcısından gelen CmsSignatureStatus, CertificateTrustStatus ve RevocationStatuste kalır. pcsValidi "algoritma profili sağlam" diye okuyun; asla "bu anahtar yeterince güçlü" diye değil. İmzalı fatura, sözleşme ya da arşiv paketi kabul eden bir Delphi uygulaması için bütün kurulum birkaç satıra sığar: ValidatePadesTrust çalıştırın, ppeiSignatureAlgorithmMismatchde reddedin, pcsUnsupported ile pcsIndeterminatei bir incelemeciye yönlendirin ve kendi RSA anahtar boyutu tabanınızı uygulayın

Bu denetimleri çalıştıran kütüphane aynı zamanda PAdES imzası da üretir; bir ekip, P-384 ya da Ed25519 ile imza atıp kendi çıktısının ISO/TS 32002 profilini sağladığını, müşteriye ulaşmadan önce teyit edebilir. Sürümler, platform desteği ve imzalama hattı, Delphi ve Lazarus için PDFium Component ürün sayfasında anlatılır