Teknik Makale

Delphi'de CMS imza ayrıştırma: DER sınırları ve OID kolları

Bir çabuk DER yardımcısının sıkça yaptığı gibi OID 2.999.3ü, yani ilk iki kolunu tek bayta paketleyerek kodlayın; çözücü geriye 1.15.3 verir. CMS okuyan kodda aynı sonuç doğuran iki hata daha vardır: komşusunun baytlarını yutan bir sertifika sayacı ve yanlış alandan okunan bir seri numarasıyla eşleştirilen signer. PDF Library for Delphi (PDFlibPas) imza okuyucusu ise /Contentsteki CMSi saf DER olarak yürür, her iç içe okumayı üst öğesiyle sınırlar, dolguyu CMSnin bildirdiği uzunlukta keser ve birleşik ilk OID kolunu base-128 ile kodlar

Bir imzanın okuma tarafına çok kod ihtiyaç duyar. Long-term validation, revocation verisi çekebilmek için önce mevcut imzadan signer sertifikasını ve onun issuerlarını dışarı çıkarmak zorundadır. Bir denetim raporu kimin imzaladığını söylemek zorundadır. Linux üzerindeki bir Lazarus derlemesi ise yaslanacak hiçbir Windows mesaj fonksiyonu bulamaz, çünkü platformun CMS çağrıları Windows dışında başarısızlığa bağlanır; PDFlibPas bu yüzden bu yürüyüşü sade Pascalda yapar ve hiçbir yerde CryptoAPI kullanmaz

İmzalı bir PDFten signer sertifikalarını okumak

Okuma tarafının tamamını beş TPDFlib metodu karşılar ve her biri InputFile, Password, FieldName alır. Her çağrı dosyayı salt okunur açar, cevabını verir ve yeniden kapatır; yönetilecek bir belge durumu yoktur. GetSignatureEmbeddedCertificateCount ile GetSignatureEmbeddedCertificateDER, CMS sertifika setini kodlama sırasında numaralandırır. GetSignatureSignerCertificateDER, verilen SignerInfoyu üreten sertifikayı döndürür. GetSignatureCertificateChainLength ile GetSignatureCertificateChainDER, o signerdan imzanın taşıdığı en uzak issuera kadar yürür. Tüm indeksler sıfır tabanlıdır

Sonuçlar AnsiString olarak döner ve öyle kalmalıdır. string ya da TStrings içinden geçen bir DER blob, bir karakter seti dönüşümüne girer ve karşıya çıkan baytlar artık ayrıştırılmaz. Kütüphanenin sertifika listelerini AnsiString dizileri olarak tutmasının ve URL listelerini satır başına bir adres içeren metin olarak döndürmesinin sebebi de budur: adresler düz ASCIIdir ve dönüşümü atlatabilir, sertifika baytları atlatamaz

uses
  SysUtils, Classes, PDFlibrary, PDFlibEnterprise;

procedure SaveDer(const FileName: string; const Der: AnsiString);
var
  Fs: TFileStream;
begin
  Fs := TFileStream.Create(FileName, fmCreate);
  try
    if Der <> '' then
      Fs.WriteBuffer(Der[1], Length(Der));
  finally
    Fs.Free;
  end;
end;

const
  Src = 'contract-signed.pdf';
  Field = 'Signature1';
var
  Pdf: TPDFlibEnterprise;
  Count, ChainLen, I: Integer;
  SignerDer, LastDer: AnsiString;
begin
  Pdf := TPDFlibEnterprise.Create;
  try
    Count := Pdf.GetSignatureEmbeddedCertificateCount(Src, '', Field);
    WriteLn(Field, ': ', Count, ' certificate(s) in the CMS');
    for I := 0 to Count - 1 do
      SaveDer(Format('embedded-%d.cer', [I]),
        Pdf.GetSignatureEmbeddedCertificateDER(Src, '', Field, I));

    SignerDer := Pdf.GetSignatureSignerCertificateDER(Src, '', Field, 0);
    if SignerDer = '' then
      raise Exception.CreateFmt('%s: signer certificate missing or not matched', [Field]);
    SaveDer('signer.cer', SignerDer);

    ChainLen := Pdf.GetSignatureCertificateChainLength(Src, '', Field, 0);
    for I := 0 to ChainLen - 1 do
      SaveDer(Format('chain-%d.cer', [I]),
        Pdf.GetSignatureCertificateChainDER(Src, '', Field, 0, I));
    if ChainLen > 0 then
    begin
      // son halkanın, imzanın gömmediği bir issueri hâlâ olabilir
      LastDer := Pdf.GetSignatureCertificateChainDER(Src, '', Field, 0, ChainLen - 1);
      WriteLn('Issuer locations: ', Pdf.GetCertificateIssuerURLs(LastDer));
    end;
  finally
    Pdf.Free;
  end;
end;

O programdaki iki sonucu yanlış okumak kolaydır. 0 sayısı kendi başına çok az şey söyler: eksik bir alan, yanlış bir parola, DER olmayan bir blob ve opsiyonel sertifika setini tamamen atlayan bir SignedData, tümü 0 ya da boş dize olarak döner. Örneğin yaptığı gibi sayının yanına alan adını da loglayın, yoksa yanlış dosyada hata ayıklarsınız. İkincisi zincir uzunluğudur. Zincir kurucu yalnızca imzaya gömülü sertifikaları kullanır; bu yüzden self-issued bir roota ulaşamadan sona eren bir zincir normaldir. Demo sertifikamızla, yani bir test rootunun verdiği sertifikayla bir dosya imzalayın, GetSignatureCertificateChainLength 1 döndürür, çünkü o root CMSde yoktur. Bir sonraki adım, GetCertificateIssuerURLsin bildirdiği adreslerden gelir; bu çağrı, long-term validation APIsinin geri kalanı gibi Enterprise sürümüne aittir

Signer eşleştirmesinin kendisi, RFC 5652 §5.3ün izin verdiği her iki SignerIdentifier biçimini de işler. issuerAndSerialNumber herkesin test ettiği biçimdir. $80 etiketli, implicitly tagged bir OCTET STRING olan [0] subjectKeyIdentifier biçimi ise elle yazılan okuyucuların en sık unuttuğu daldır ve kendini anahtar tanımlayıcısıyla bildiren signerlar gerçekten onu üretir. issuer-and-serial biçimi kullanıldığında iki yarımın da eşleşmesi gerekir: bir seri numarası yalnızca tek issuer içinde benzersizdir, bu yüzden yalnızca seriye göre eşleşmek başka bir CAya ait bir sertifikaya düşebilir

Gerçekte /Contentsin ne kadarı CMS?

Yalnızca dış SEQUENCEnin kapsadığı önek geçerlidir ve PDFlibCMSRead birimindeki PLTrimCMSPadding sonrasındaki her şeyi keser. Bunun sebebi sıralamadır. ISO 32000-1 §12.8.1, /ByteRangein imza değeri var olmadan önce sabitlenmesini şart koşar; bu yüzden bir signer /Contents hex dizesini baştan rezerve eder, cömertçe boyutlar ve CMS belli olunca kullanılmayan kuyruğu sıfırlarla doldurur. Tipik bir imzalı dosya bu nedenle CMSden sonra, signerın fazladan rezerve ettiği kadar uzun bir sıfır dizisi taşır

PLTrimCMSPadding ilk TLVyi okur, $30 etiketini şart koşar ve o öğenin sonuna kadarki baytları döndürür. Ona 30 03 02 01 00 00 00 00 verin, ilk beş baytı geri alırsınız; 'not der' verin, boş bir dize alırsınız. Kuyruk baytlarının yasal olduğu tek yer bu en üst düzeydir. Öğenin tüm tamponu tüketmesini şart koşan katı bir kural sıradan imzalı dosyaları reddederken, her derinlikte uygulanan "arta kalan her şey sorun değildir" türü gevşek bir kural, iç içe alanların sahibi olmadıkları baytları okumasının tam da sebebidir

PDFlibPas PLTrimCMSPadding, rezerve edilmiş /Contents hex dizesinin ilk TLVsini okur, $30 etiketini şart koşar ve sıfır dolgusunu dış SEQUENCEnin bildirdiği uzunlukta keser; tampon düzgün kurulu bir SEQUENCE ile başlamadığında boş sonuç döndürür
Kuyruk baytları yalnızca en üst düzeyde yasaldır; rezerve slot /ByteRange için sabit kalmak zorundadır — daha derin okumalar üst öğeyle sınırlı kuralı alır

Bir DER okuyucusu üst öğenin bitiş ofsetine neden ihtiyaç duyar?

Çünkü iç içe bir öğe yalnızca üst öğesinin içinde bitiyorsa geçerlidir ve tamponun sonuna karşı yapılan kontrol bunu kanıtlamaz. PDFlibASN1deki DERReadTLV her öğeyi tüm dizeyle sınırlar, sona taşacak uzunlukları reddeder ve aritmetiği bir çıkarma olarak yapar; böylece elle hazırlanmış dört baytlık bir $7FFFFFFF uzunluğu kontrolü negatife sarmalayamaz. Bu bellek güvenliğidir. Öğenin bulunduğu yere ait olup olmadığı konusunda hiçbir şey söylemez

issuerAndSerialNumberı 40 bayt bildiren ama içindeki issuer Namein 60 iddia ettiği bir SignerInfo düşünün. Her bayt hâlâ tamponun içindedir; tamponla sınırlı bir okuyucu Namei kabul eder, ardından gelen digest algoritmasından "seri numarasını" okur ve o çifti gömülü sertifikalarla karşılaştırır. Hiçbir şey başarısız olmaz. Karşılaştırma kimi zaman yanlış sertifikayla bile başarılı olur

PDFlibPas her iç içe DER okumasını üst öğeyle sınırlar: 40 baytlık issuerAndSerialNumber içindeki 60 baytlık issuer Name, eski tampon sınırlı DERReadTLV tarafından kabul edilir ve seri numarası digestAlgorithmdan okunur; ReadTLVWithin ise ParentEndi aşan bitişe sahip hiçbir öğeyi kabul etmez
Tamponun içinde olmak bellek güvenliği, üst öğenin içinde olmak doğruluktur — PDFlibPas üst bitiş ofsetini her CMS düzeyine taşır ki düşmanca bir uzunluk komşusunun baytlarını ödünç alamasın

PDFlibPas CMS yürüyüşçüsü, üst öğenin bitiş konumunu ContentInfodan (RFC 5652 §3) [0] EXPLICIT sarmalayıcısına, SignedData alanlarına (§5.1), her SignerInfoya ve tanımlayıcısına, signer eşleştirilirken okunan tbsCertificate alanlarına kadar her okumaya taşır. Kendi yürüyüşçünüzü, bir timestamp tokenı ya da bir OCSP yanıtı için, herkese açık DERReadTLV üzerine yazacaksanız aynı desen bir düzine satırdır:

uses
  PDFlibASN1;

// Tek çocuk okuması; çocuk, üst öğesinin ötesinde bitecekse reddedilir.
function ReadChild(const Data: AnsiString; ParentEnd: Integer;
  var Offset: Integer; out Tag: Byte; out Start, Len: Integer): Boolean;
begin
  Result := False;
  if (Offset < 1) or (Offset >= ParentEnd) then
    Exit;                          // üst öğenin içinde hiçbir şey kalmadı
  if not DERReadTLV(Data, Offset, Tag, Start, Len) then
    Exit;
  Result := Offset <= ParentEnd;  // Offset artık çocuğun bitişinin bir ötesinde
end;

// İçeriği Data[SetStart .. SetEnd - 1] aralığını kapsayan bir SET OFun
// SEQUENCE üyelerini sayar. Taşan ilk üyede durur.
function CountSequences(const Data: AnsiString; SetStart, SetEnd: Integer): Integer;
var
  Offset, Start, Len: Integer;
  Tag: Byte;
begin
  Result := 0;
  Offset := SetStart;
  while Offset < SetEnd do
  begin
    if not ReadChild(Data, SetEnd, Offset, Tag, Start, Len) then
      Break;                       // yeniden senkron yok: hizalama bozuldu
    if Tag = $30 then
      Inc(Result);
  end;
end;

Breaka dikkat edin. certificates seti ile signerInfos seti içinde PLExtractCMSCertificates aynı şeyi yapar: setin sonunu aşan bir öğe döngüyü durdurur ve fonksiyon, o ana kadar kabul ettiği sertifikaları döndürür. Sonraki crls ya da signerInfos baytlarını asla son sertifikaya yapıştırmaz. Kötü öğeyi atlayıp devam etmek caziptir ve yanlış karardır. Bildirilen bir uzunluk bir kez yanlış olduğunda okuyucu artık bir sonraki öğenin nerede başladığını bilmez ve herhangi bir "kurtarma", hangi baytın etikete benzediği üzerine bir tahminden ibarettir. Döngü durunca, ikinci sertifikası tek bayt taşan bir set, 1 sayısını ve ilk sertifikanın baytlarını kodlandıkları haliyle verir

2.999.3 neden 1.15.3 olarak çıktı?

Bir OIDnin ilk iki kolu tek bir alt tanımlayıcıda birleşir ve o alt tanımlayıcı, diğer tüm kollar gibi base-128 ile kodlanır — tek bayt değildir. X.690 §8.19.4 değeri 40 * arc1 + arc2 olarak tanımlar. Onu Byte(...) ile yazan bir kodlayıcı, 2.47nin karşılığı olan 127ye kadar doğrudur. 2.999 için toplam 1079dur; byte cast 55i tutar ve 55, 1.15 olarak çözülür. Tanımlayıcı artık ağacın başka bir dalını adlandırır ve hiçbir şey şikayet etmez. 128 ile 255 arası değerler farklı bozulur: cast, continuation biti kurulmuş tek bayt yazar ve çözücü bir sonraki kolu onun içine yutar

Kısayol gerçek kodda bu kadar uzun ayakta kalır, çünkü PKI tanımlayıcılarının çoğu sınıra hiç ulaşmaz. 1.2.840, 2.5.29 ve 0.4.0 altındaki her şeyin birleşik ilk değeri 128in çok altındadır; bu yüzden yalnızca sıradan imza OIDsinden kurulu bir test paketi ikinci baytı hiç çalıştırmaz. Çizgiyi yalnızca 2.48 ve üzeri joint-iso-itu-t kolları geçer. PDFlibPasta tek bir fonksiyon, DER_OID, hem signed attribute kodlayıcısına hem DERFindExtensionByOIDin içindeki aramaya hem de SignedData content-type kontrolüne hizmet eder; böylece yazma ile eşleştirme birbirinden kayamaz. Test vektörleri sınırın iki yanına da konmalıdır:

uses
  SysUtils, PDFlibASN1;

function Hex(const S: AnsiString): string;
var
  I: Integer;
begin
  Result := '';
  for I := 1 to Length(S) do
    Result := Result + IntToHex(Byte(S[I]), 2) + ' ';
  Result := Trim(Result);
end;

procedure Check(const Oid, Expected: AnsiString);
begin
  if Hex(DER_OID(Oid)) <> Expected then
    WriteLn('MISMATCH ', Oid, ': ', Hex(DER_OID(Oid)), ' expected ', Expected)
  else
    WriteLn('ok       ', Oid);
end;

begin
  Check('2.47.1',               '06 02 7F 01');     // tek bayta sığan son değer
  Check('2.48.1',               '06 03 81 00 01');  // iki bayta çıkan ilk değer
  Check('2.999.3',              '06 03 88 37 03');  // Byte cast, 1.15.3 verir
  Check('2.5.29.14',            '06 03 55 1D 0E');
  Check('1.2.840.113549.1.7.2', '06 09 2A 86 48 86 F7 0D 01 07 02');
end.
PDFlibPas DER_OID, ilk iki OID kolunu 40 * arc1 + arc2 olarak birleştirip toplamı UInt64te base-128 kodlar; 2.999.3 böylece 06 03 88 37 03 olur, eski Byte cast ise 55i tutup tanımlayıcıyı sessizce 1.15.3 olarak çözüyordu
PKI kollarının çoğu sınıra hiç ulaşmaz, bugün hayatta olmasının sebebi bu — 2.48 ve üzeri joint-iso-itu-t kolları iki bayt ister ve test 2.47 ile 2.48i iki yanda tutar

Aynı aritmetik satırında gizlenmiş bir taşma daha vardır. DER_OID kolları Int64e ayrıştırır; yani yasal bir ikinci kol Int64.MaxValue kadar büyük olabilir ve arc1 = 2 için 80 eklemek işaretli 64-bit bir integerı taşırır. Birleşik değer bu yüzden UInt64te tutulur; Int64.MaxValue + 80i sarmalanmadan taşır. Bu kadar büyük OIDleri kimse üretmez ama elle hazırlanmış bir dize yine de bir tane isteyebilir. DER_OIDin içindeki on baytlık scratch tampon, 64-bit bir değerin gereksinebileceği on adet 7-bitlik grubu barındırır; dolayısıyla 2.9223372036854775807 bile sarmalanmak yerine on baytlık bir alt tanımlayıcı olarak kodlanır

CMS yürüyüşçüsü neyi kabul eder ve doğrulama nerede durur?

PDFlibCMSRead, baytları RFC 5652nin söylediği yerde döndürür ve bütün işi budur. Hiçbir imza değerini, hiçbir digesti, hiçbir geçerlilik süresini kontrol etmez. Yürüyüşcü yalnızca DER kabul eder: DERReadTLV belirsiz uzunlukları ve çok baytlı etiket numaralarını reddeder, bu yüzden standartlara uymayan bir signerın BER kodlu CMSi sıfır sertifika bildirir. BERin kısmi bir ayrıştırılmasını değil bunu tercih ederiz. Uygulamada ele veren şey, dış $30 etiketinin hemen ardından gelen $80 uzunluk baytıdır; belirsiz uzunluklu bir SEQUENCE tam da böyle başlar

Attribute certificatelar ve CertificateChoicesun diğer alternatifleri, certificates seti yürürken atlanır; zincir kurmanın ve revocation aramalarının kullanabildiği X.509 sertifikası yalnızca düz Certificate alternatifidir. Kriptografik her şey, sahibi olan kodda kalır: bu, Delphide PAdES imzalama ve ByteRange doğrulama yazısındaki bayt kapsamı kontrolleriyle başlar, bir PDF imzalandıktan sonra neyin değiştiğini sınıflandırma ile sürer. Bildirilen uzunluklara güvenmeme alışkanlığı, saldırıya uğramış dosyalara karşı bir Pascal PDF ayrıştırıcısını sertleştirme yazısında da akar

Yukarıda gösterilen sertifika çıkarma, zincir kurma ve long-term validation çağrıları, losLab PDF Library for Delphinin parçasıdır; kitaplık Delphi, C++Builder ve Lazarus üzerinde çalışır, böylece aynı imza okuma kodu bir Windows servisinde de bir Linux derlemesinde de çalışır