Ticket #2874: encryption_sigmon_v2.diff

mythtv/libs/libmythtv/dtvsignalmonitor.cpp

@@ -1 +1 @@
 #include <unistd.h>
 
 #include "dtvchannel.h"
+#include "dvbchannel.h"
 #include "dtvsignalmonitor.h"
 #include "scanstreamdata.h"
 #include "mpegtables.h"
@@ -30 +31 @@
       seenVCT(tr("Seen")+" VCT", "seen_vct", 1, true, 0, 1, 0),
       seenNIT(tr("Seen")+" NIT", "seen_nit", 1, true, 0, 1, 0),
       seenSDT(tr("Seen")+" SDT", "seen_sdt", 1, true, 0, 1, 0),
+      seenCrypt(tr("Seen")+" Crypt", "seen_crypt", 1, true, 0, 1, 0),
       matchingPAT(tr("Matching")+" PAT", "matching_pat", 1, true, 0, 1, 0),
       matchingPMT(tr("Matching")+" PMT", "matching_pmt", 1, true, 0, 1, 0),
       matchingMGT(tr("Matching")+" MGT", "matching_mgt", 1, true, 0, 1, 0),
       matchingVCT(tr("Matching")+" VCT", "matching_vct", 1, true, 0, 1, 0),
       matchingNIT(tr("Matching")+" NIT", "matching_nit", 1, true, 0, 1, 0),
       matchingSDT(tr("Matching")+" SDT", "matching_sdt", 1, true, 0, 1, 0),
+      matchingCrypt(tr("Matching")+" Crypt", "matching_crypt",
+                    1, true, 0, 1, 0),
       majorChannel(-1), minorChannel(-1),
       networkID(0), transportID(0),
       detectedNetworkID(0), detectedTransportID(0),
@@ -112 +116 @@
         list<<seenSDT.GetName()<<seenSDT.GetStatus();
         list<<matchingSDT.GetName()<<matchingSDT.GetStatus();
     }
+    if (flags & kDTVSigMon_WaitForCrypt)
+    {
+        list<<seenCrypt.GetName()<<seenCrypt.GetStatus();
+        list<<matchingCrypt.GetName()<<matchingCrypt.GetStatus();
+    }
     if (error != "")
     {
         list<<"error"<<error;
@@ -140 +149 @@
     seenVCT.SetValue(    (flags & kDTVSigMon_VCTSeen)  ? 1 : 0);
     seenNIT.SetValue(    (flags & kDTVSigMon_NITSeen)  ? 1 : 0);
     seenSDT.SetValue(    (flags & kDTVSigMon_SDTSeen)  ? 1 : 0);
+    seenCrypt.SetValue(  (flags & kDTVSigMon_CryptSeen)? 1 : 0);
     matchingPAT.SetValue((flags & kDTVSigMon_PATMatch) ? 1 : 0);
     matchingPMT.SetValue((flags & kDTVSigMon_PMTMatch) ? 1 : 0);
     matchingMGT.SetValue((flags & kDTVSigMon_MGTMatch) ? 1 : 0);
     matchingVCT.SetValue((flags & kDTVSigMon_VCTMatch) ? 1 : 0);
     matchingNIT.SetValue((flags & kDTVSigMon_NITMatch) ? 1 : 0);
     matchingSDT.SetValue((flags & kDTVSigMon_SDTMatch) ? 1 : 0);
+    matchingCrypt.SetValue((flags & kDTVSigMon_CryptMatch) ? 1 : 0);
 }
 
 void DTVSignalMonitor::UpdateListeningForEIT(void)
@@ -177 +188 @@
     DBG_SM(QString("SetChannel(%1, %2)").arg(major).arg(minor), "");
     if (GetATSCStreamData() && (majorChannel != major || minorChannel != minor))
     {
-        RemoveFlags(kDTVSigMon_PATSeen | kDTVSigMon_PATMatch |
-                    kDTVSigMon_PMTSeen | kDTVSigMon_PMTMatch |
-                    kDTVSigMon_VCTSeen | kDTVSigMon_VCTMatch);
+        RemoveFlags(kDTVSigMon_PATSeen   | kDTVSigMon_PATMatch |
+                    kDTVSigMon_PMTSeen   | kDTVSigMon_PMTMatch |
+                    kDTVSigMon_VCTSeen   | kDTVSigMon_VCTMatch |
+                    kDTVSigMon_CryptSeen | kDTVSigMon_CryptMatch);
         majorChannel = major;
         minorChannel = minor;
         GetATSCStreamData()->SetDesiredChannel(major, minor);
@@ -192 +204 @@
     DBG_SM(QString("SetProgramNumber(%1)").arg(progNum), "");
     if (programNumber != progNum)
     {
-        RemoveFlags(kDTVSigMon_PMTSeen | kDTVSigMon_PMTMatch);
+        RemoveFlags(kDTVSigMon_PMTSeen   | kDTVSigMon_PMTMatch |
+                    kDTVSigMon_CryptSeen | kDTVSigMon_CryptMatch);
         programNumber = progNum;
         if (GetStreamData())
             GetStreamData()->SetDesiredProgram(programNumber);
@@ -211 +224 @@
         return;
     }
 
-    RemoveFlags(kDTVSigMon_PMTSeen | kDTVSigMon_PMTMatch |
-                kDTVSigMon_SDTSeen | kDTVSigMon_SDTMatch);
+    RemoveFlags(kDTVSigMon_PMTSeen   | kDTVSigMon_PMTMatch |
+                kDTVSigMon_SDTSeen   | kDTVSigMon_SDTMatch |
+                kDTVSigMon_CryptSeen | kDTVSigMon_CryptMatch);
 
     transportID   = tsid;
     networkID     = netid;
@@ -328 +342 @@
     if ((hasVideo >= GetStreamData()->GetVideoStreamsRequired()) &&
         (hasAudio >= GetStreamData()->GetAudioStreamsRequired()))
     {
+        if (pmt->IsEncrypted())
+        {
+#ifdef USING_DVB
+            DVBChannel* dvbchan = dynamic_cast<DVBChannel*>(GetDTVChannel());
+            if (dvbchan)
+                dvbchan->SetPMT(pmt);
+#endif
+            AddFlags(kDTVSigMon_WaitForCrypt);
+            GetStreamData()->TestDecryption(pmt);
+        }
         AddFlags(kDTVSigMon_PMTMatch);
     }
     else
@@ -432 +456 @@
     }
 }
 
+void DTVSignalMonitor::HandleEncryptionStatus(uint, bool enc_status)
+{
+    AddFlags(kDTVSigMon_CryptSeen);
+    if (!enc_status)
+        AddFlags(kDTVSigMon_CryptMatch);
+}
+
 ATSCStreamData *DTVSignalMonitor::GetATSCStreamData()
 {
     return dynamic_cast<ATSCStreamData*>(stream_data);
@@ -479 +510 @@
             return false;
     if ((flags & kDTVSigMon_WaitForSDT) && !matchingSDT.IsGood())
             return false;
+    if ((flags & kDTVSigMon_WaitForCrypt) && !matchingCrypt.IsGood())
+            return false;
 
     return true;
 }

mythtv/libs/libmythtv/dtvsignalmonitor.h

@@ -86 +86 @@
     void HandlePAT(const ProgramAssociationTable*);
     void HandleCAT(const ConditionalAccessTable*) {}
     void HandlePMT(uint, const ProgramMapTable*);
+    void HandleEncryptionStatus(uint, bool enc_status);
 
     // ATSC Main
     void HandleSTT(const SystemTimeTable*) {}
@@ -118 +119 @@
     SignalMonitorValue seenVCT;
     SignalMonitorValue seenNIT;
     SignalMonitorValue seenSDT;
+    SignalMonitorValue seenCrypt;
     SignalMonitorValue matchingPAT;
     SignalMonitorValue matchingPMT;
     SignalMonitorValue matchingMGT;
     SignalMonitorValue matchingVCT;
     SignalMonitorValue matchingNIT;
     SignalMonitorValue matchingSDT;
+    SignalMonitorValue matchingCrypt;
 
     // ATSC tuning info
     int                majorChannel;

mythtv/libs/libmythtv/dvbrecorder.h

@@ -81 +81 @@
     void HandlePAT(const ProgramAssociationTable*);
     void HandleCAT(const ConditionalAccessTable*) {}
     void HandlePMT(uint pid, const ProgramMapTable*);
+    void HandleEncryptionStatus(uint, bool) { }
 
     void SetStreamData(MPEGStreamData*);
     MPEGStreamData* GetStreamData(void) { return _stream_data; }

mythtv/libs/libmythtv/hdhrrecorder.h

@@ -46 +46 @@
     void HandlePAT(const ProgramAssociationTable*);
     void HandleCAT(const ConditionalAccessTable*) {}
     void HandlePMT(uint pid, const ProgramMapTable*);
+    void HandleEncryptionStatus(uint, bool) {}
 
     // MPEG Single Program Stream Listener
     void HandleSingleProgramPAT(ProgramAssociationTable *pat);

mythtv/libs/libmythtv/mpeg/mpegstreamdata.cpp

@@ -727 +727 @@
 bool MPEGStreamData::ProcessTSPacket(const TSPacket& tspacket)
 {
     bool ok = !tspacket.TransportError();
-    if (ok && !tspacket.ScramplingControl() && tspacket.HasPayload() &&
-        IsListeningPID(tspacket.PID()))
+
+    if (IsEncryptionTestPID(tspacket.PID()))
+    {
+        ProcessEncryptedPacket(tspacket);
+    }
+    else if (ok && !tspacket.ScramplingControl() && tspacket.HasPayload() &&
+             IsListeningPID(tspacket.PID()))
     {
         HandleTSTables(&tspacket);
     }
+
     return ok;
 }
 
@@ -778 +784 @@
     return it != _pids_audio.end();
 }
 
+bool MPEGStreamData::IsEncryptionTestPID(uint pid) const
+{
+    QMap<uint, bool>::const_iterator it = _pids_encryption.find(pid);
+    return it != _pids_encryption.end();
+}
+
 void MPEGStreamData::SavePartialPES(uint pid, PESPacket* packet)
 {
     pid_pes_map_t::iterator it = _partial_pes_packet_cache.find(pid);
@@ -1189 +1201 @@
         }
     }
 }
+
+void MPEGStreamData::AddEncryptionTestPID(uint pid)
+{
+    AddListeningPID(pid);
+    _pids_encryption[pid] = false;
+    _pids_encrypted_packets[pid] = 0;
+    _pids_decrypted_packets[pid] = 0;
+}
+
+void MPEGStreamData::RemoveEncryptionTestPID(uint pid)
+{
+    RemoveListeningPID(pid);
+    _pids_encryption.erase(pid);
+    _pids_encrypted_packets.erase(pid);
+    _pids_decrypted_packets.erase(pid);
+}
+
+void MPEGStreamData::TestDecryption(const ProgramMapTable* pmt)
+{
+    VERBOSE(VB_RECORD,
+            QString("Setting decryption Signal Monitoring "
+                    "for program id %1 up.").arg(pmt->ProgramNumber()));
+
+    bool encrypted = pmt->IsProgramEncrypted();
+    for (uint i = 0; i < pmt->StreamCount(); i++)
+        if ((encrypted || pmt->IsStreamEncrypted(i)) &&
+            (pmt->IsVideo(i, _sistandard) || pmt->IsAudio(i, _sistandard)))
+            AddEncryptionTestPID(pmt->StreamPID(i));
+}
+
+#define SAFE_DECRYPTED_PACKETS 8
+#define SAFE_ENCRYPTED_PACKETS 10000
+
+/** \fn MPEGStreamData::ProcessEncryptedPacket(const TSPacket& tspacket)
+ *  \brief counts en/decrypted packets to decide if a stream is en/decrypted
+ */
+void MPEGStreamData::ProcessEncryptedPacket(const TSPacket& tspacket)
+{
+    uint pid = tspacket.PID();
+
+    if (tspacket.ScramplingControl())
+    {
+        _pids_decrypted_packets[pid] = 0;
+
+        // if a fair amount of encrypted packets is passed assume that
+        // the stream is not decryptable now
+        if (++_pids_encrypted_packets[pid] > SAFE_ENCRYPTED_PACKETS &&
+            !_pids_encryption[pid])
+        {
+            _pids_encryption[pid] = true;
+            VERBOSE(VB_IMPORTANT,
+                    QString("Couldn't decrypt stream on PID %1.").arg(pid));
+
+            _listener_lock.lock();
+            for (uint i = 0; i < _mpeg_listeners.size(); i++)
+                _mpeg_listeners[i]->HandleEncryptionStatus(0, true);
+            _listener_lock.unlock();
+        }
+    }
+    else
+    {
+        _pids_encrypted_packets[pid] = 0;
+        if (++_pids_decrypted_packets[pid] > SAFE_DECRYPTED_PACKETS)
+        {
+            RemoveEncryptionTestPID(pid);
+            VERBOSE(VB_RECORD,
+                    QString("Stream on PID %1 is now unencrypted").arg(pid));
+        }
+    }
+
+    // report only success if all stream com unencrypted
+    if (_pids_encryption.size() < 1)
+    {
+        _listener_lock.lock();
+        for (uint i = 0; i < _mpeg_listeners.size(); i++)
+            _mpeg_listeners[i]->HandleEncryptionStatus(0, false);
+        _listener_lock.unlock();
+    }
+}

mythtv/libs/libmythtv/mpeg/mpegstreamdata.h

@@ -68 +68 @@
     virtual bool ProcessTSPacket(const TSPacket& tspacket);
     virtual int  ProcessData(unsigned char *buffer, int len);
     inline  void HandleAdaptationFieldControl(const TSPacket* tspacket);
+    virtual void TestDecryption(const ProgramMapTable* pmt);
 
     // Listening
     virtual void AddListeningPID(uint pid)  { _pids_listening[pid] = true; }
     virtual void AddNotListeningPID(uint pid){_pids_notlistening[pid] = true;}
     virtual void AddWritingPID(uint pid)    { _pids_writing[pid] = true;   }
     virtual void AddAudioPID(uint pid)      { _pids_audio[pid] = true;     }
+    virtual void AddEncryptionTestPID(uint pid);
 
     virtual void RemoveListeningPID(uint pid) { _pids_listening.erase(pid);  }
     virtual void RemoveNotListeningPID(uint pid)
         { _pids_notlistening.erase(pid); }
     virtual void RemoveWritingPID(uint pid) { _pids_writing.erase(pid);    }
     virtual void RemoveAudioPID(uint pid)   { _pids_audio.erase(pid);      }
+    virtual void RemoveEncryptionTestPID(uint pid);
 
     virtual bool IsListeningPID(uint pid) const;
     virtual bool IsNotListeningPID(uint pid) const;
     virtual bool IsWritingPID(uint pid) const;
     virtual bool IsAudioPID(uint pid) const;
+    virtual bool IsEncryptionTestPID(uint pid) const;
 
     virtual QMap<uint, bool> ListeningPIDs(void) const
         { return _pids_listening; }
 
+    virtual QMap<uint, bool> EncryptionTestPID(void) const
+        { return _pids_encryption; }
+
+
     // Table versions
     void SetVersionPAT(uint tsid, int version, uint last_section)
     {
@@ -214 +222 @@
     void DeletePartialPES(uint pid);
     void ProcessPAT(const ProgramAssociationTable *pat);
     void ProcessPMT(const ProgramMapTable *pmt);
+    void ProcessEncryptedPacket(const TSPacket&);
 
     static int ResyncStream(unsigned char *buffer, int curr_pos, int len);
 
@@ -237 +246 @@
     QMap<uint, bool>          _pids_notlistening;
     QMap<uint, bool>          _pids_writing;
     QMap<uint, bool>          _pids_audio;
+    QMap<uint, bool>          _pids_encryption;
+    QMap<uint, uint>          _pids_encrypted_packets;
+    QMap<uint, uint>          _pids_decrypted_packets;
 
     // Signals
     mutable QMutex            _listener_lock;

mythtv/libs/libmythtv/mpeg/mpegtables.cpp

@@ -281 +281 @@
  */
 bool ProgramMapTable::IsEncrypted(void) const
 {
+    bool encrypted = IsProgramEncrypted();
+
+    for (uint i = 0; !encrypted && i < StreamCount(); i++)
+        encrypted |= IsStreamEncrypted(i);
+
+    return encrypted;
+}
+
+/** \fn ProgramMapTable::IsProgramEncrypted(void) const
+ *  \brief Returns true iff PMT's ProgramInfo contains CA descriptor.
+ */
+bool ProgramMapTable::IsProgramEncrypted(void) const
+{
     desc_list_t descs = MPEGDescriptor::ParseOnlyInclude(
         ProgramInfo(), ProgramInfoLength(), DescriptorID::conditional_access);
 
@@ -295 +308 @@
         //VERBOSE(VB_IMPORTANT, "DTVsm: "<<cad.toString());
     }
 
-    for (uint i = 0; i < StreamCount(); i++)
-    {
-        desc_list_t descs = MPEGDescriptor::ParseOnlyInclude(
-            StreamInfo(i), StreamInfoLength(i),
-            DescriptorID::conditional_access);
+    return encrypted;
+}
 
-        for (uint j = 0; j < descs.size(); j++)
-        {
-            ConditionalAccessDescriptor cad(descs[j]);
-            encryption_system[cad.PID()] = cad.SystemID();
-            encrypted |= cad.SystemID();
+/** \fn ProgramMapTable::IsStreamEncrypted(uint i) const
+ *  \brief Returns true iff PMT contains CA descriptor.
+ *
+ *  \param i index of stream
+ */
+bool ProgramMapTable::IsStreamEncrypted(uint i) const
+{
+    desc_list_t descs = MPEGDescriptor::ParseOnlyInclude(
+        StreamInfo(i), StreamInfoLength(i), DescriptorID::conditional_access);
 
-            //VERBOSE(VB_IMPORTANT, "DTVsm: "<<cad.toString());
-        }
+    bool encrypted = false;
+    QMap<uint,uint> encryption_system;
+    for (uint j = 0; j < descs.size(); j++)
+    {
+        ConditionalAccessDescriptor cad(descs[j]);
+        encryption_system[cad.PID()] = cad.SystemID();
+        encrypted |= cad.SystemID();
+
+        //VERBOSE(VB_IMPORTANT, "DTVsm: "<<cad.toString());
     }
 
     return encrypted;

mythtv/libs/libmythtv/mpeg/mpegtables.h

@@ -461 +461 @@
         Parse();
     }
 
-    ProgramMapTable(const PSIPTable& table) : PSIPTable(table)
+        ProgramMapTable(const PSIPTable& table) : PSIPTable(table)
     {
         assert(TableID::PMT == TableID());
         Parse();
@@ -528 +528 @@
     bool IsVideo(uint i, QString sistandard) const;
     bool IsAudio(uint i, QString sistandard) const;
     bool IsEncrypted(void) const;
+    bool IsProgramEncrypted(void) const;
+    bool IsStreamEncrypted(uint) const;
     /// Returns true iff PMT contains a still-picture video stream
     bool IsStillPicture(QString sistandard) const;
     /// Returns a string representation of type at stream index i

mythtv/libs/libmythtv/mpeg/streamlisteners.h

@@ +1 @@
+// -*- Mode: c++ -*-
 #ifndef _STREAMLISTENERS_H_
 #define _STREAMLISTENERS_H_
 
@@ -41 +42 @@
     virtual void HandlePAT(const ProgramAssociationTable*) = 0;
     virtual void HandleCAT(const ConditionalAccessTable*) = 0;
     virtual void HandlePMT(uint program_num, const ProgramMapTable*) = 0;
+    virtual void HandleEncryptionStatus(uint program_number, bool) = 0;
 };
 
 class MPEGSingleProgramStreamListener

mythtv/libs/libmythtv/signalmonitor.h

@@ -148 +148 @@
     static const uint64_t kDTVSigMon_SDTSeen    = 0x0000000080ULL;
     /// We've seen the FireWire STB power state
     static const uint64_t kFWSigMon_PowerSeen   = 0x0000000100ULL;
+    /// We can encrypt the stream
+    static const uint64_t kDTVSigMon_CryptSeen  = 0x0000000200ULL;
 
     /// We've seen a PAT matching our requirements
     static const uint64_t kDTVSigMon_PATMatch   = 0x0000001000ULL;
@@ -167 +169 @@
     static const uint64_t kDTVSigMon_SDTMatch   = 0x0000080000ULL;
     /// We've seen a FireWire STB power state matching our requirements
     static const uint64_t kFWSigMon_PowerMatch  = 0x0000100000ULL;
+    /// We can encrypt the stream
+    static const uint64_t kDTVSigMon_CryptMatch = 0x0000200000ULL;
 
     static const uint64_t kDTVSigMon_WaitForPAT = 0x0001000000ULL;
     static const uint64_t kDTVSigMon_WaitForPMT = 0x0002000000ULL;
@@ -176 +180 @@
     static const uint64_t kDTVSigMon_WaitForSDT = 0x0020000000ULL;
     static const uint64_t kDTVSigMon_WaitForSig = 0x0040000000ULL;
     static const uint64_t kFWSigMon_WaitForPower= 0x0080000000ULL;
+    static const uint64_t kDTVSigMon_WaitForCrypt=0x0100000000ULL;
 
-    static const uint64_t kDTVSigMon_WaitForAll = 0x00FF000000ULL;
+    static const uint64_t kDTVSigMon_WaitForAll = 0x01FF000000ULL;
 
     /// Wait for the Signal to Noise Ratio to rise above a threshhold
-    static const uint64_t kDVBSigMon_WaitForSNR = 0x0100000000ULL;
+    static const uint64_t kDVBSigMon_WaitForSNR = 0x1000000000ULL;
     /// Wait for the Bit Error Rate to fall below a threshhold
-    static const uint64_t kDVBSigMon_WaitForBER = 0x0200000000ULL;
+    static const uint64_t kDVBSigMon_WaitForBER = 0x2000000000ULL;
     /// Wait for uncorrected FEC blocks to fall below a threshhold
-    static const uint64_t kDVBSigMon_WaitForUB  = 0x0400000000ULL;
+    static const uint64_t kDVBSigMon_WaitForUB  = 0x4000000000ULL;
     /// Wait for rotor to complete turning the antenna
-    static const uint64_t kDVBSigMon_WaitForPos = 0x0800000000ULL;
+    static const uint64_t kDVBSigMon_WaitForPos = 0x8000000000ULL;
 
   protected:
     pthread_t    monitor_thread;
@@ -228 +233 @@
         str += "SDT,";
     if (SignalMonitor::kFWSigMon_PowerSeen   & flags)
         str += "STB,";
+    if (SignalMonitor::kDTVSigMon_CryptSeen  & flags)
+        str += "Crypt,";
 
     str += ") Match(";
     if (SignalMonitor::kDTVSigMon_PATMatch   & flags)
@@ -248 +255 @@
         str += "SDT,";
     if (SignalMonitor::kFWSigMon_PowerMatch  & flags)
         str += "STB,";
+    if (SignalMonitor::kDTVSigMon_CryptMatch & flags)
+        str += "Crypt,";
 
     str += ") Wait(";
     if (SignalMonitor::kDTVSigMon_WaitForPAT & flags)
@@ -266 +275 @@
         str += "Sig,";
     if (SignalMonitor::kFWSigMon_WaitForPower& flags)
         str += "STB,";
+    if (SignalMonitor::kDTVSigMon_WaitForCrypt & flags)
+        str += "Crypt,";
 
     if (SignalMonitor::kDVBSigMon_WaitForSNR & flags)
         str += "SNR,";

mythtv/libs/libmythtv/signalmonitorvalue.h

@@ +1 @@
+// -*- Mode: c++ -*-
 #ifndef SIGNALMONITORVALUES_H
 #define SIGNALMONITORVALUES_H
 

mythtv/libs/libmythtv/siscan.h

@@ -85 +85 @@
     void HandlePAT(const ProgramAssociationTable*);
     void HandleCAT(const ConditionalAccessTable*) { }
     void HandlePMT(uint, const ProgramMapTable*) { }
+    void HandleEncryptionStatus(uint, bool) { }
 
     // ATSC Main
     void HandleSTT(const SystemTimeTable*) {}

mythtv/libs/libmythtv/tv_play.cpp

@@ -4686 +4686 @@
     float snr  = 0.0f;
     uint  ber  = 0xffffffff;
     int   pos  = -1;
-    QString pat(""), pmt(""), mgt(""), vct(""), nit(""), sdt("");
+    QString pat(""), pmt(""), mgt(""), vct(""), nit(""), sdt(""), crypt("");
     QString err = QString::null, msg = QString::null;
     for (it = slist.begin(); it != slist.end(); ++it)
     {
@@ -4736 +4736 @@
             sdt = it->IsGood() ? "s" : "_";
         else if ("matching_sdt" == it->GetShortName())
             sdt = it->IsGood() ? "S" : sdt;
+        else if ("seen_crypt" == it->GetShortName())
+            crypt = it->IsGood() ? "c" : "_";
+        else if ("matching_crypt" == it->GetShortName())
+            crypt = it->IsGood() ? "C" : crypt;
     }
     if (sig)
         infoMap["signal"] = QString::number(sig); // use normalized value
@@ -4753 +4757 @@
     if ((pos >= 0) && (pos < 100))
         sigDesc += " | " + tr("Rotor %1\%").arg(pos,2);
 
-    sigDesc = sigDesc + QString(" | (%1%2%3%4%5%6%7) %8")
+    sigDesc = sigDesc + QString(" | (%1%2%3%4%5%6%7%8) %9")
         .arg(slock).arg(pat).arg(pmt).arg(mgt).arg(vct)
-        .arg(nit).arg(sdt).arg(sigMsg);
+        .arg(nit).arg(sdt).arg(crypt).arg(sigMsg);
 
     if (!err.isEmpty())
         sigDesc = err;