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:
Bereich
Wo ist was
0x000000 – 0x00FFFF
Bootloader (evtl. sehr kompakt, lädt Hauptfirmware)
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.
Bereich (Hex)
Größe
Inhalt
Analyse
0x000000 – 0x01FFFF
128 KB
Firmware aktiv
Viele ASCII-Strings und Menütexte, vermutlich Bootloader + Hauptstartcode.
0x020000 – 0x07FFFF
384 KB
Leerer Bereich / Padding
Bereich nur mit 0xFF, wahrscheinlich ungenutzter Flash-Space oder Reservierung.
0x080000 – 0x0DFFFF
384 KB
Firmware aktiv
Hauptbereich der eigentlichen Firmware, viele Strings und Logikblöcke.
0x0E0000 – 0x0FFFFF
128 KB
Leer / Padding
Wieder ungenutzte Blöcke.
0x100000 – 0x7FFFFF
7 MB
Komplett leer (0xFF)
Speicher komplett leer oder gespiegelte Wiederholung des 4MB-Flashbereichs.
Speicherbereiche (Memory Map)
Adresse (Hex)
Bereich
Funktion
0x00000000 – 0x0003FFFF
Flash-ROM (32-bit breit)
Bootloader + Firmware 256KB sichtbar
0x10000000 – 0x1001FFFF
SDRAM
Arbeitsbereich für Runtime-Daten, ECM/EMM Verarbeitung
0x20000000 – 0x2000FFFF
CI-Host-Interface
Steuerung der Kommunikation mit dem Fernseher/Receiver
0x30000000 – 0x3000FFFF
Smartcard-Interface
ISO7816-kompatible Register (T=0/T=1-Protokoll)
0x40000000 – 0x40000FFF
Interrupt-Controller
Verwaltung von CI-Ereignissen, Smartcard-Events, Timern
0x50000000 – 0x5000FFFF
GPIO Ports / LEDs
Steuerung von LEDs, Schaltern, Debug-Ports
0x60000000 – 0x6000FFFF
UART Debug
Serielle Debug-Ausgabe (evtl. deaktiviert bei Produktion)
Register
Adresse
Beschreibung
CI_COMMAND
0x20000004
Steuerregister für CI-Kommandos an den Host
CI_DATA_IN
0x20000008
Eingangsdaten vom Host
CI_DATA_OUT
0x2000000C
Ausgangsdaten zum Host
SC_COMMAND
0x30000004
Smartcard-Befehlsschnittstelle
SC_STATUS
0x30000008
Status der eingesteckten Smartcard
SC_DATA
0x3000000C
Smartcard-Datenpuffer
LED_CONTROL
0x50000010
Steuerung von LEDs (z. B. grün/rot für Statusanzeigen)
UART_TX
0x60000004
UART Sende-Register
UART_RX
0x60000008
UART Empfangs-Register
Bekannte Chipsätze von OPUS Taiwan:
Chip
Besonderheit
Bemerkung
OPUS SII0982
Früher CI-Controller
Genutzt in frühen Unicam-Varianten und ersten CAM-Serien.
OPUS SN0803
Bessere CI-Performance, Dual ECM möglich
Hauptchip in AlphaCrypt 2.2, Onys CAM, späteren Unicam-Generationen.
OPUS SN0805
CI+ Ansatz (experimentell)
Geplante Weiterentwicklung für CI+, aber kaum verbreitet (nur Testmuster).
OPUS SN0802
Kompakte Variante für Low-Cost CAMs
Selten verwendet, vermutlich für abgespeckte Module gedacht.
OPUS SN0810
Embedded Secure CAM Controller
Advanced Features, CI+ möglich, vermutlich nur als OEM-Muster produziert.
OPUS CA100
Reines Smartcard-Handling
Dient zur Anbindung von Kartenlesern ohne kompletten CI-Stack.
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)
Kommentar veröffentlichen