Das ist das Onys CI Modul

Das Unicam CI Modul

Das Alpha Crypt 2.2

Vergleich: Unicam CI vs. Onys CAM CI vs. AlphaCrypt 2.2

Was fällt besonders auf?

• Unicam:
  • Flexibel und günstig, perfekt für Benutzer, die verschiedene CAM-Firmware flashen möchten.
  • Hardware relativ einfach, aber zuverlässig.
• Onys CAM:
  • Fast baugleich mit Unicam, aber FRAM statt SDRAM → Vorteil: höhere Robustheit bei häufigem Zugriff.
  • Etwas stabilere Konstruktion, möglicherweise zielgerichtet auf spezielle Märkte oder professionelle Anwendungen.
• AlphaCrypt 2.2:
  • Deutlich höherwertige Bestückung: Spansion-Flash, OPUS SN0803, schneller 16MB SDRAM.
  • Sehr robust, geeignet für Pay-TV- und professionelle Netzwerke (z. B. Krankenhäuser, Hotels).
  • Häufige Verwendung bei Systemen wie HD+, Sky, Kabel Deutschland (mit legalen Modulversionen).

🛠️ Technische Zusammenfassung:

• OPUS Controller Familie: Wird in allen drei Modulen verwendet, wobei die neuere Generation SN0803 auch Dual-CA-Streams besser unterstützt.
• Flash-Größe: Alle drei etwa gleich (4MB).
• RAM:
  • Unicam → Standard-SDRAM.
  • Onys → FRAM (für mehr Robustheit).
  • AlphaCrypt → High-End SDRAM (großzügig dimensioniert).
• Programmierbarkeit:
  • Unicam und Onys sind stark für private Modifikationen genutzt worden (z. B. alternative CA-Software).
  • AlphaCrypt hatte lange Zeit „offizielle Updates“ durch Mascom, Updates wie One4All (z.B. Multi-CAS) waren möglich.

Was fällt noch auf ? Das PCB Design bzw. die Revision 01,03,09

Alle diese alten Maxcam, OnysCam,Unicam und das Alphacrypt sind vom gleichen Hersteller.

OPUS Taiwan

Es wird kein Revers-Engineering , es ist ein Hardware vergleich und wie sich die Module unterscheiden! Es wurde keine Software Dekompiliert oder sonstiges!

Mascom hat seit Anfang an erstklassige Arbeit geleistet und dem Verbraucher alle Türen aufgelassen, wie damals diese blöde Pinabfrage oder das man auch Aufzeichnen konnte. Herrn Gruber danke für die schöne Zeit und alles gute. Das Alphacrypt wurde schon damals als Allrounder bezeichnet und sogar als Schweizertaschenmesser unter den CI Modulen. Mascom hat Europa mit einem legalen ALL IN ONE Modul ausgestatet und die Softwareupdates kamen all die Jahre per OTA.

Das SMC Die (Chip)

Bei dem OPUS 0803 speziell ist die Strucktur so:

Interpretation:

• Der Bootloader initialisiert vermutlich den OPUS SN0803 Controller:
  • Initiales RAM Setup.
  • Grundlegendes CI-Handshake.
  • Laden der Hauptfirmware aus Flash in SDRAM.
• Danach übernimmt die Firmware:
  • Verwalten der CI-Sessions.
  • Entschlüsseln von ECM/EMM.
  • Steuern der Smartcard.
  • Verwaltung der Benutzeroberfläche („PIN erforderlich“, „Dauer“, „Preis“, „Service Center“).
• Dual-ECM-Fähigkeit (zwei Programme entschlüsseln) wird sehr wahrscheinlich über getrennte CA-Sessions innerhalb dieser Firmware umgesetzt.

Speicherbereiche (Memory Map)

Bekannte Chipsätze von OPUS Taiwan:

Was passierte mit Opus Taiwan?

Nach der Einführung von CI+ mit sehr restriktiven Lizenzauflagen ab etwa 2008/2009 wurde es für Firmen wie OPUS wirtschaftlich unattraktiv, weiterhin offene Chips zu entwickeln.

CI+-fähige CAMs brauchten teure Lizenzen (Trust Authority etc.), die OPUS sich nicht leisten konnte.

Große Hersteller wie Neotion (Frankreich) und SMIT (China) dominierten danach den Markt.

OPUS Microsystems wurde ab etwa 2014 praktisch unsichtbar, wahrscheinlich aufgelöst oder aufgekauft.

** Nach Recherche wurde die Firma an STMicroelectronics verkauft.

Der folgende Code ist ein Beispiel!

import struct
import base64
import hashlib
from cryptography.hazmat.primitives import serialization, hashes
from cryptography.hazmat.primitives.asymmetric import padding

# 1. RSA Public Key aus Firmware-Dump extrahieren
def extract_public_key(dump_path, der_path, pem_path):
    data = open(dump_path, 'rb').read()
    # Suche DER-Sequence (0x30 0x82)
    for i in range(len(data) - 4):
        if data[i] == 0x30 and data[i+1] == 0x82:
            length = (data[i+2] << 8) + data[i+3]
            der = data[i:i+4+length]
            with open(der_path, 'wb') as f:
                f.write(der)
            # PEM
            b64 = base64.b64encode(der).decode()
            pem = '-----BEGIN PUBLIC KEY-----
' + '
'.join([b64[j:j+64] for j in range(0, len(b64), 64)]) + '
-----END PUBLIC KEY-----
'
            with open(pem_path, 'w') as f:
                f.write(pem)
            return True
    return False

# 2. SHA-256 Digest der Firmware berechnen def compute_digest(payload_path):
    data = open(payload_path, 'rb').read()
    return hashlib.sha256(data).digest()

# 3. Signatur verifizieren
def verify_signature(pem_path, payload_path, sig_path):
    pub_key = serialization.load_pem_public_key(open(pem_path, 'rb').read())
    payload = open(payload_path, 'rb').read()
    signature = open(sig_path, 'rb').read()
    pub_key.verify(
        signature,
        payload,
        padding.PKCS1v15(),
        hashes.SHA256()
    )
    print('Signature valid')

# 4. Neue Firmware signieren (Herstellerprivatkey benötigt)
def sign_firmware(privkey_path, payload_path, sig_out_path):
    priv_key = serialization.load_pem_private_key(open(privkey_path, 'rb').read(), password=None)
    payload = open(payload_path, 'rb').read()
    signature = priv_key.sign(
        payload,
        padding.PKCS1v15(),
        hashes.SHA256()
    )
    with open(sig_out_path, 'wb') as f:
        f.write(signature)
    print('Firmware signed, signature saved to', sig_out_path)