INRIA RF Fingerprinting Model Collection for Physical Layer Authentication (ONNX)

Model Info

This repository contains a comprehensive collection of machine learning models developed by INRIA.

These models implement Physical Layer Authentication (PLA) using RF Fingerprinting. They are designed to secure wireless networks by identifying devices based on the unique physical characteristics (fingerprints) of their radio hardware, rather than just their digital credentials.

This record provides a "Model Zoo" covering various experimental scenarios (Trials), machine learning architectures, and feature selection techniques.

For a detailed description of the framework, methodology, and experimental setup, see the:

Paper: Robust Device Authentication in Multi-Node Networks: ML-Assisted Hybrid PLA Exploiting Hardware Impairments

 Source Code: https://github.com/mlsysops-eu/model-physical-layer-authentication

Authors

• Ildi Alla (Inria Centre at the University of Lille)
• Selma Yahia (Inria Centre at the University of Lille)
• Valéria Loscrì (Inria Centre at the University of Lille)
• Hossien Eldeeb (University of Cambridge)

Purpose

These models perform Binary Classification to distinguish between trusted and malicious devices:

• Authorized (Target): The specific device allowed to access the network.
• Rogue (Malicious): An attacker, imposter, or unknown device trying to mimic a trusted node.

The models are exported in ONNX format (Opset 18) to ensure interoperability and are designed to run on edge devices for real-time authentication.

Repository Structure

Since this repository contains multiple models, the files are organized using the following directory structure:

/models
    ├── /trial_1                 # Experimental Scenario 1
    │     ├── /random_forest
    │     │     ├── /pca         # Feature Selection Method: PCA
    │     │     │     └── model_device3.onnx
    │     │     └── /anova       # Feature Selection Method: ANOVA
    │     │           └── ...
    │     └── /xgb
    │           └── ...
    ├── /trial_2                 # Experimental Scenario 2
    └── ...

• Trial: Corresponds to specific experimental setups (specific sets of authorized vs. rogue devices).

• Model Type: The architecture used (e.g., xgb, svc, knn).

• Feature Selection: The method used to reduce the input vector size (e.g., pca, anova, mutual_info).

• Filename: Indicates the specific device ID the model was trained to authenticate (e.g., model_device3.onnx protects Device 3).

Training Data

The models were trained on raw I/Q signal data collected using a BladeRF AX4 Software Defined Radio (SDR) and GNU Radio. The dataset captures the "transient" phase of RF signals (the turn-on/turn-off characteristics), which contains the most distinctive hardware impairments used for fingerprinting.

This dataset is publicly available on Zenodo:

INRIA I/Q Signal Dataset for RF Fingerprinting and Physical Layer Authentication

Training data characteristics:

• Source Hardware: BladeRF AX4 (20 MHz sampling rate).

• Signal Processing: Transient detection, Low-pass filtering, Discrete Gabor Transform (DGT).

• Input Features: Statistical moments (Variance, Skewness, Kurtosis, Entropy) extracted from diagonal patches of the spectrogram.

Model Architecture

This collection includes the following architectures, all converted to standard ONNX format:

• XGBoost (XGB): Gradient boosting for high-performance classification.

• Random Forest (RF): Ensemble learning method using decision trees.

• Support Vector Classifier (SVC): Polynomial kernel SVM.

• K-Nearest Neighbors (KNN): Instance-based learning.

• Logistic Regression: Linear model for baseline comparison.

Specific hyperparameters (e.g., number of trees, kernel type) for each architecture can be found in the models/model_config.json file included in this record.

Model Specification (Common Interface)

All models in this collection share the same input/output interface specifications:

Inputs

• Data Type: float32

• Shape: [batch_size, n_features]

• batch_size: Number of samples (typically 1 for real-time inference).

• n_features: Dynamic. This depends on the specific model file selected (e.g., a PCA model might expect 20 features, while an ANOVA model might expect 50).

• Note: You must check the expected input shape of the specific .onnx file before feeding data.

Outputs

• Data Type: int64 (Label) and float32 (Probabilities)

• Shape: [batch_size, 1]

• Interpretation:

  • Label 0: ROGUE / MALICIOUS DEVICE (Access Denied)

  • Label 1: AUTHORIZED / TRUSTED DEVICE (Access Granted)

Limitations

• Feature Dependency: The input must be a feature vector extracted using the specific Gabor Transform & Statistical parameters defined in the paper. Raw I/Q samples cannot be used directly.

• Device Specificity: A model named model_device3.onnx is trained only to recognize Device 3. It will treat all other devices (even other trusted ones) as "Rogue" relative to Device 3.

Usage Demo

To run any model from this collection, use the provided inference_demo.py script.

1. Setup Environment

python3.13 -m venv venv
source venv/bin/activate
pip install -r requirements

2. Run Inference

Select a specific model file from the folder structure and run:

import onnxruntime as ort
import numpy as np

# 1. Select your model file
model_path = "./models/trial_1/xgb/pca/model_device3.onnx"
session = ort.InferenceSession(model_path)

# 2. Check how many features this specific model needs
input_meta = session.get_inputs()[0]
n_features = input_meta.shape[1]
print(f"Selected model expects {n_features} features.")

# 3. Generate input (Replace with actual calculated features)
# Shape: [1, n_features]
dummy_input = np.random.rand(1, n_features).astype(np.float32)

# 4. Run Inference
outputs = session.run(None, {input_meta.name: dummy_input})
predicted_label = outputs[0][0]

# 5. Interpret
if predicted_label == 1:
    print("✅ ACCESS GRANTED: Authorized Device Detected")
else:
    print("🚨 ALERT: Rogue/Malicious Device Detected")

Citation

If you use these models or the PLA code in your research, please cite the following paper:

@inproceedings{alla2024robust,
  title={Robust Device Authentication in Multi-Node Networks: ML-Assisted Hybrid PLA Exploiting Hardware Impairments},
  author={Alla, Ildi and Yahia, Selma and Loscri, Valeria and Eldeeb, Hossien},
  booktitle={Annual Computer Security Applications Conference (ACSAC)},
  year={2024}
}

If you wish to cite this specific model collection, please use the citation generated by Zenodo (located in the right sidebar of this record).

Acknowledgement & Funding

This work is part of the MLSysOps project, funded by the European Union’s Horizon Europe research and innovation programme under grant agreement No. 101092912.

More information about the project is available at https://mlsysops.eu/