Anatomi Risiko: Supply Chain Attack pada Model On-Device

Distribusi model machine learning ke perangkat klien (edge devices) memperluas permukaan serangan aplikasi. Model serialization format seperti format standar PyTorch (.pt atau .pth) secara inheren menggunakan modul pickle. Format ini mengeksekusi opcodes arbitrer saat deserialisasi dilakukan via torch.load(), memungkinkan penyerang menjalankan kode eksekusi arbitrer (RCE) langsung di lingkungan target.

Selain ancaman injeksi kode, bobot model (tensors) dapat dimanipulasi melalui serangan degradasi performa atau backdoor payload tanpa merusak struktur file pembungkusnya. Penerapan hardening export model on-device membutuhkan validasi berlapis sebelum runtime menginisialisasi tensor ke memori perangkat.

1. Eliminasi Pickle: Transisi ke Safe Serialized Format

Langkah pertama memitigasi eksekusi kode adalah mengganti format penyimpanan state berbasis pickle ke format deklaratif yang hanya memetakan raw buffer tensor, seperti safetensors.

# Konversi PyTorch state_dict ke format SafeTensors aman
import torch
from safetensors.torch import save_file, load_file

def export_hardened_weights(model: torch.nn.Module, output_path: str):
    # Ekstraksi representasi tensor murni tanpa hierarki Python bytecode
    state_dict = model.state_dict()
    # Pastikan setiap bobot di-cast ke representasi deterministik jika diperlukan
    clean_state_dict = {k: v.contiguous() for k, v in state_dict.items()}
    save_file(clean_state_dict, output_path)

# Sisi intake runtime: memuat tensor tanpa mengeksekusi metadata objek
clean_tensors = load_file("model_weights.safetensors")

Format deklaratif seperti SafeTensors atau FlatBuffers pada TFLite/Core ML memisahkan metadata struktur model dari alokasi memori biner, mencegah terjadinya injeksi kelas deserialisasi.

2. Verifikasi Integritas via Kriptografi (ECDSA & SHA-256)

Validasi integritas memastikan bobot yang diunduh atau dimasukkan ke aplikasi tidak mengalami tampering di level penyimpanan lokal maupun jaringan (Man-in-the-Middle). Gunakan skema verifikasi asimetris ECDSA dengan digest SHA-256.

Implementasi Verifikasi Sisi Python

import hashlib
from cryptography.hazmat.primitives.asymmetric import ec
from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.primitives.serialization import load_pem_public_key

def verify_model_artifact(file_path: str, signature: bytes, public_key_pem: bytes) -> bool:
    # 1. Hitung SHA-256 digest dari binary file
    hasher = hashlib.sha256()
    with open(file_path, "rb") as f:
        while chunk := f.read(65536):
            hasher.update(chunk)
    digest = hasher.digest()

    # 2. Verifikasi tanda tangan digital ECDSA
    public_key = load_pem_public_key(public_key_pem)
    try:
        public_key.verify(signature, digest, ec.ECDSA(hashes.SHA256()))
        return True
    except Exception:
        return False

Implementasi Verifikasi Sisi Swift (CryptoKit)

import Foundation
import CryptoKit

func verifyModelSignature(fileURL: URL, signatureData: Data, publicKeyPEM: String) throws -> Bool {
    let fileData = try Data(contentsOf: fileURL, options: .mappedIfSafe)
    let digest = SHA256.hash(data: fileData)
    
    // Inisialisasi public key ECDSA (P-256)
    guard let keyData = Data(base64Encoded: publicKeyPEM),
          let publicKey = try? P256.Signing.PublicKey(rawRepresentation: keyData) else {
        throw ModelSecurityError.invalidKey
    }
    
    let signature = try P256.Signing.ECDSASignature(rawRepresentation: signatureData)
    return publicKey.isValidSignature(signature, for: digest)
}

3. Sanitasi Bobot dan Deteksi Anomali Tensor

Pemeriksaan kriptografi hanya memvalidasi asal file, bukan isi numerik di dalamnya. Sebelum runtime mendaftarkan tensor ke engine inferensi, lakukan sanitasi terhadap anomali float seperti nilai NaN, Infinity, atau deviasi statistik drastis yang menandakan serangan pembajakan bobot.

import numpy as np

def sanitize_tensor_buffer(tensor_name: str, array: np.ndarray, threshold_std: float = 10.0):
    # Deteksi NaN dan Pos/Neg Infinity
    if not np.all(np.isfinite(array)):
        raise ValueError(f"Sanitasi gagal: Tensor {tensor_name} memuat NaN atau Infinity.")

    # Deteksi aktivasi ekstrim yang tidak normal
    mean = np.mean(array)
    std = np.std(array)
    max_val = np.max(np.abs(array))

    if max_val > (np.abs(mean) + threshold_std * std):
        raise ValueError(f"Anomali bobot terdeteksi pada {tensor_name}: Deviasi melampaui batas wajar.")

4. Runtime Privilege Restriction & Memory Isolation

Setelah lolos verifikasi dan sanitasi, proses pemuatan ke memori harus diisolasi guna meminimalkan impak eksploitasi zero-day pada parser native runtime (misalnya Core ML engine atau ONNX Runtime engine):

  • App Sandbox & File Permissions: Pastikan direktori penyimpanan model berstatus read-only langsung setelah proses unduhan dan verifikasi selesai. Hindari menyimpan model di direktori publik bersama (shared caches).
  • Address Space Layout Randomization (ASLR): Pada target native (C++/Swift), kompilasi wrapper runtime dengan flag hardening compiler (-fstack-protector-strong, -D_FORTIFY_SOURCE=2).
  • Disable Dynamic Code Loading: Hindari pemanggilan library eksternal secara dinamis saat graph model diinisialisasi. Pasang runtime flag strict parsing agar engine menolak operator kustom tak terdaftar.

Ringkasan Trade-off

Penambahan verifikasi ECDSA dan sanitasi per-tensor menambahkan latensi startup time (I/O reading & hashing overhead). Gunakan alokasi memory-mapped file (mmap) untuk membaca buffer besar secara efisien tanpa menduplikasi alokasi memori fisik sebelum model dinyatakan valid untuk inferensi.