File indexing completed on 2024-12-29 04:51:09

 /*
     SPDX-FileCopyrightText: 2019 Volker Krause <vkrause@kde.org>
 
     SPDX-License-Identifier: LGPL-2.0-or-later
 */
 
 #include "vdvticketparser.h"
 #include "vdvdata_p.h"
 #include "vdvcertificate_p.h"
 #include "iso9796_2decoder_p.h"
 #include "logging.h"
 
 #include "../asn1/berelement.h"
 
 #include <QByteArray>
 #include <QDebug>
 
 using namespace KItinerary;
 
 VdvTicketParser::VdvTicketParser() = default;
 VdvTicketParser::~VdvTicketParser() = default;
 
 bool VdvTicketParser::parse(const QByteArray &data)
 {
     // (1) find the certificate authority reference (CAR) to identify the key to decode the CV certificate
     const auto sig = BER::TypedElement<TagSignature>(data);
     if (!sig.isValid()) {
         qCDebug(Log) << "Invalid VDV ticket signature.";
         return false;
     }
     const auto sigRemainder = BER::TypedElement<TagSignatureRemainder>(data, sig.size());
     if (!sigRemainder.isValid()) {
         qCDebug(Log) << "Invalid VDV signature remainder.";
         return false;
     }
 
     const auto cvCertOffset = sig.size() + sigRemainder.size();
     auto cvCert = VdvCertificate(data, cvCertOffset);
     if ((!cvCert.isValid() && !cvCert.needsCaKey())) {
         qCDebug(Log) << "Invalid CV signature:" << cvCert.isValid() << cvCertOffset << cvCert.size();
         return false;
     }
 
     const auto carOffset = cvCertOffset + cvCert.size();
     const auto carBlock = BER::TypedElement<TagCaReference>(data, carOffset);
     if (!carBlock.isValid()) {
         qCDebug(Log) << "Invalid CA Reference.";
         return false;
     }
     const auto car = carBlock.contentAt<VdvCaReference>(0);
     if (!car) {
         qCDebug(Log) << "Cannot obtain CA Reference.";
         return false;
     }
     qCDebug(Log) << "CV CAR:" << QByteArray(car->region, 5) << car->serviceIndicator << car->discretionaryData << car->algorithmReference << car->year;
 
     const auto caCert = VdvPkiRepository::caCertificate(car);
     if (!caCert.isValid()) {
         qCWarning(Log) << "Could not find CA certificate" << QByteArray(reinterpret_cast<const char*>(car), sizeof(VdvCaReference)).toHex();
         return false;
     }
 
     // (2) decode the CV certificate
     cvCert.setCaCertificate(caCert);
     if (!cvCert.isValid()) {
         qCWarning(Log) << "Failed to decode CV certificate.";
         return false;
     }
 
     // (3) decode the ticket data using the decoded CV certificate
     Iso9796_2Decoder decoder;
     decoder.setRsaParameters(cvCert.modulus(), cvCert.modulusSize(), cvCert.exponent(), cvCert.exponentSize());
     decoder.addWithRecoveredMessage(sig.contentData(), sig.contentSize());
     decoder.add(sigRemainder.contentData(), sigRemainder.contentSize());
 
     // (4) profit!
     m_ticket = VdvTicket(decoder.recoveredMessage(), data);
     return true;
 }
 
 bool VdvTicketParser::maybeVdvTicket(const QByteArray& data)
 {
     if (data.size() < 352) {
         return false;
     }
 
     // signature header
     const auto sig = BER::TypedElement<TagSignature>(data);
     if (!sig.isValid()) {
         return false;
     }
     const auto rem = BER::TypedElement<TagSignatureRemainder>(data, sig.size());
     if (!rem.isValid()) {
         return false;
     }
 
     // verify the "VDV" marker is there
     return strncmp((const char*)(rem.contentData() + rem.contentSize() - 5), "VDV", 3) == 0;
 }
 
 VdvTicket VdvTicketParser::ticket() const
 {
     return m_ticket;
 }