simulcrypt 0.2.2

DVB SimulCrypt (ETSI TS 103 197) head-end protocol: ECMG client, EMMG server, control words
Documentation
use std::{
    fmt::Write as _,
    time::Duration,
};

use simulcrypt::{
    CasConfig,
    EcmgConfig,
    Event,
    ServiceCas,
    ServiceConfig,
    Simulcrypt,
};

fn env_or(name: &str, default: &str) -> String {
    std::env::var(name).unwrap_or_else(|_| default.to_string())
}

fn env_parse<T: std::str::FromStr>(name: &str, default: T) -> T {
    std::env::var(name)
        .ok()
        .and_then(|value| value.parse().ok())
        .unwrap_or(default)
}

fn hex(bytes: &[u8]) -> String {
    bytes.iter().fold(String::new(), |mut out, byte| {
        let _ = write!(out, "{byte:02x}");
        out
    })
}

fn cas_config_from_env(prefix: &str, id: &str, default_port: u16) -> CasConfig {
    let host: std::net::IpAddr = env_parse(&format!("{prefix}_HOST"), [127, 0, 0, 1].into());
    let port: u16 = env_parse(&format!("{prefix}_PORT"), default_port);
    let channel_id: u16 = env_parse(&format!("{prefix}_CHANNEL_ID"), 1);
    let super_cas_id =
        u32::from_str_radix(&env_or(&format!("{prefix}_SUPER_CAS_ID"), "0b000001"), 16)
            .unwrap_or_else(|_| panic!("invalid {prefix}_SUPER_CAS_ID"));

    CasConfig {
        id: id.into(),
        name: id.into(),
        super_cas_id,
        first_stream_id: 0,
        ecmg: EcmgConfig::new(channel_id, std::net::SocketAddr::new(host, port)),
        emmg: None,
    }
}

/// One service scrambled by two independent CAS at once: a shared CW and crypto period, but each
/// CAS returns its own ECM for the same control word. This is the point of simulcrypt - several
/// parallel conditional access systems in one stream.
#[tokio::main]
async fn main() {
    tracing_subscriber::fmt::init();

    let simulcrypt = Simulcrypt::new();

    let cas_a = simulcrypt
        .acquire_cas(cas_config_from_env("CAS_A", "cas-a", 2222))
        .expect("acquire_cas failed for CAS A");
    let cas_b = simulcrypt
        .acquire_cas(cas_config_from_env("CAS_B", "cas-b", 2223))
        .expect("acquire_cas failed for CAS B");

    let ecm_pid: u16 = env_parse("ECM_PID", 100);
    let crypto_period_secs: u64 = env_parse("CRYPTO_PERIOD_SECS", 10);

    let mut service = simulcrypt
        .open_service(&ServiceConfig {
            name: "multi-cas-demo".into(),
            crypto_period: Duration::from_secs(crypto_period_secs),
            cas: vec![
                ServiceCas {
                    cas: cas_a.cas(),
                    ecm_pid,
                    access_criteria: vec![],
                },
                ServiceCas {
                    cas: cas_b.cas(),
                    ecm_pid,
                    access_criteria: vec![],
                },
            ],
        })
        .expect("open_service failed");

    for stream in service.streams() {
        tracing::info!(
            "stream registered: cas={:?} ecm_pid={} stream_id={}",
            stream.cas,
            stream.ecm_pid,
            stream.stream_id
        );
    }

    while let Some(event) = service.recv().await {
        match event {
            Event::Cw {
                cp_number,
                parity,
                cw,
            } => {
                println!(
                    "Cw  cp={cp_number} parity={parity:?} cw={} (shared by both CAS)",
                    hex(&cw)
                );
            }
            Event::Ecm {
                cas,
                stream_id,
                cp_number,
                data,
                ..
            } => {
                println!(
                    "Ecm cas={cas:?} stream_id={stream_id} cp={cp_number:?} len={}",
                    data.len()
                );
            }
            Event::State { cas, state } => {
                tracing::info!("CAS {:?} state changed: {:?}", cas, state);
            }
            Event::Emm { .. } | Event::Ts(_) => {}
        }
    }
}