📋 Complete Deployment Process
This guide follows the complete 9-phase deployment process shown above, taking you from planning to live network operation.
🔧 What You'll Build
📡 Portable GSM BTS
Build a complete portable GSM Base Transceiver Station using YateBTS on Raspberry Pi 4. Perfect for GSM penetration testing, emergency communications, and mobile network research.
- BladeRF Micro A4 support
- LimeSDR Mini compatibility
- Complete hardware guide
🔒 Security Testing Platform
Comprehensive IoT security testing platform for penetration testers and security researchers. Test mobile devices, IoT sensors, and cellular networks with professional-grade tools.
⚡ Easy Installation
One-command installation with auto-detection of SDR devices. Optimized for Raspberry Pi 4 with comprehensive setup guides and troubleshooting support.
🌍 Global Configuration
Pre-configured for multiple countries including Portugal, USA, UK, and Europe. Regulatory compliance guides and country-specific frequency settings included.
Your Progress
📋 Prerequisites and System Requirements
📊 System Architecture Overview
Complete system architecture showing hardware, software, and service layers
Hardware Requirements
Essential Hardware Components
- Raspberry Pi 4 with 8GB RAM - Complete specifications and compatibility
- BladeRF Mini A4 or LimeSDR Mini SDR device - Primary software defined radio
- GeeekPi DeskPi Lite Case with M.2 support - Optimal cooling and storage
- 2TB M.2 SSD or 64GB+ MicroSD card - High-performance storage
- 5V/3A USB-C power supply with proper certification
- GSM-compatible SIM cards (2-3 for testing)
- GSM antenna (800MHz-2.6GHz range recommended)
Additional Requirements
- Computer for initial setup (Windows, macOS, or Linux)
- Ethernet cable or WiFi access for internet connectivity
- SSH client (PuTTY, Terminal, or similar)
- Text editor (nano, vim, or VS Code)
- MicroSD card reader (if using SD card instead of M.2)
- USB-C to USB-A adapter (if needed)
Software Requirements
Operating System
- Ubuntu 22.04 LTS (recommended)
- Ubuntu 20.04 LTS (compatible)
- Debian 11+ (alternative)
- Raspberry Pi OS (basic support)
Required Software Packages
- Git (version control)
- Build tools (gcc, g++, make)
- CMake (build system)
- Python 3.8+ (scripting)
- Node.js 16+ (web interface)
- Apache2 (web server)
- PHP 8.0+ (web interface backend)
Network Requirements
🌐 Network Configuration
Internet Connection: Stable broadband connection (minimum 10 Mbps download, 5 Mbps upload)
Local Network: Ethernet connection preferred for initial setup
Firewall: Ensure ports 22 (SSH), 80 (HTTP), and 443 (HTTPS) are accessible
DNS: Configure proper DNS servers (8.8.8.8, 1.1.1.1 recommended)
Legal and Regulatory Considerations
⚠️ Important Legal Notice
Frequency Regulations: Ensure you have proper licensing for GSM frequencies in your region
Power Limits: Stay within legal power transmission limits (typically 2W ERP)
Interference: Do not interfere with licensed cellular networks
Testing Only: This system is intended for educational and testing purposes
💡 Pro Tip
Make sure you have all hardware components before starting. The installation process requires uninterrupted access to the internet and may take 15-30 minutes. Consider using a UPS (Uninterruptible Power Supply) for stable power during installation.
🏗️ Step 1: Hardware Assembly
Assemble the GeeekPi DeskPi Lite Case
Install M.2 SSD:
- Insert 2TB M.2 SSD into the M.2 slot
- Secure with provided screw
- Connect power and data cables
Install Raspberry Pi 4:
- Place Pi 4 into the case
- Connect GPIO pins
- Secure with provided screws
Connect Components:
- Connect power button cable
- Connect PWM fan cable
- Ensure all connections are secure
Connect External Devices
BladeRF Mini A4 or LimeSDR Mini:
- Connect to USB 3.0 port
- Ensure secure connection
- Connect antenna (if available)
- LimeSDR Mini: Use uFL to SMA adapters for antenna connection
Network Connection:
- Connect Ethernet cable
- Or configure WiFi during setup
Power Supply:
- Connect 5V/3A USB-C power supply
- Verify power LED is on
⚠️ Important
Double-check all connections before powering on. Loose connections can cause hardware damage or installation failures.
💻 Step 2: Complete System Installation
Pre-Installation Checklist
📋 Before You Begin
- ✅ All hardware components assembled and connected
- ✅ Stable internet connection available
- ✅ At least 2GB free disk space
- ✅ Power supply providing stable 5V/3A
- ✅ Network connectivity (Ethernet or WiFi)
- ✅ SSH access enabled (if remote installation)
Initial Boot and System Access
- Power on the Raspberry Pi and wait for boot sequence
- First boot may take 5-10 minutes (system initialization)
- Login with default credentials or your configured user
- Verify network connectivity with:
ping google.com
# Check system information
uname -a
cat /etc/os-release
free -h
df -h
System Update and Package Installation
# Update package lists and system
sudo apt update && sudo apt upgrade -y
# Install essential development tools
sudo apt install -y git curl wget nano htop build-essential cmake
# Install additional dependencies
sudo apt install -y python3 python3-pip nodejs npm apache2 php php-cli
# Install SDR-specific packages
sudo apt install -y libusb-1.0-0-dev libusb-1.0-0 pkg-config
# Install BladeRF dependencies
sudo apt install -y libbladerf-dev libbladerf2
Package Installation Details
Build Tools: Essential for compiling YateBTS from source
Web Server: Apache2 and PHP for the management interface
SDR Libraries: Required for BladeRF Mini A4 communication
Node.js: For modern web interface components
Download and Prepare YateBTS
# Clone the RFS-Portable-BTS repository
git clone https://github.com/TelcoSec/RFS-Portable-BTS.git
cd RFS-Portable-BTS
# Verify repository contents
ls -la
ls -la install/
# Make installation scripts executable
chmod +x install/install.sh
chmod +x install/verify.sh
# Check script permissions
ls -la install/
Repository Structure
The repository contains:
- install/ - Automated installation scripts
- docs/ - Complete documentation
- config/ - Configuration templates
- scripts/ - Utility scripts
Run Optimized Installation (v2.0)
# Start the optimized installation process (auto-detects SDR device)
./install/install.sh
# Or specify your SDR device explicitly:
./install/install.sh --bladerf-micro-a4 # For BladeRF Micro A4
./install/install.sh --limesdr-mini # For LimeSDR Mini
./install/install.sh --help # Show all options
# Advanced options:
./install/install.sh --dry-run # Simulate installation
./install/install.sh --verbose # Detailed output
./install/install.sh --backup # Create backup before install
🚀 New Installation Features (v2.0)
Advanced Features:
- ✅ Auto-detection of SDR devices (BladeRF Micro A4 or LimeSDR Mini)
- ✅ Comprehensive error handling with rollback capabilities
- ✅ Visual progress tracking with real-time status updates
- ✅ Automatic backup/restore system for configuration files
- ✅ Parallel processing for faster compilation
- ✅ Multi-level logging with color-coded output
- ✅ Dry-run mode for testing without changes
- ✅ Device-specific optimizations for maximum performance
Phase 1 - Dependencies (5-10 minutes):
- Installs all required system packages
- Downloads and compiles YateBTS from source
- Installs SDR drivers and firmware (device-specific)
- Installs Asterisk PBX for voice services
Phase 2 - Configuration (5-10 minutes):
- Creates YateBTS configuration files (device-specific)
- Sets up systemd services
- Configures Apache web server
- Installs web management interface
- Configures Portugal-optimized settings (ANACOM compliant)
Phase 3 - Optimization (5-10 minutes):
- Applies device-specific performance optimizations
- Configures real-time kernel parameters
- Sets up monitoring and logging
- Creates backup and recovery scripts
Total Installation Time: 15-30 minutes depending on internet speed
Installation Verification
# Run comprehensive verification
./install/verify.sh
# Check individual components
systemctl status yatebts
systemctl status apache2
bladeRF-cli --version
Verification Checklist
The verification script checks:
- ✅ System requirements (RAM, disk space, CPU)
- ✅ YateBTS installation and configuration
- ✅ BladeRF Mini A4 hardware detection
- ✅ Systemd services status
- ✅ Network configuration and connectivity
- ✅ Web interface accessibility
- ✅ File permissions and ownership
- ✅ Log file creation and rotation
Post-Installation Configuration
# Set up initial user account (if needed)
sudo useradd -m -s /bin/bash yatebts
sudo usermod -aG sudo yatebts
# Configure log rotation
sudo nano /etc/logrotate.d/yatebts
# Set up automatic updates (optional)
sudo apt install -y unattended-upgrades
sudo dpkg-reconfigure unattended-upgrades
🎉 Installation Complete!
Your YateBTS system is now installed and ready for configuration. The next step is to configure your GSM network parameters and test the system.
⚙️ Step 3: Advanced Configuration
Network Planning and Frequency Selection
📡 Frequency Planning
GSM 900 MHz Band: ARFCN 975-1023 (Uplink: 890-915 MHz, Downlink: 935-960 MHz)
GSM 1800 MHz Band: ARFCN 512-885 (Uplink: 1710-1785 MHz, Downlink: 1805-1880 MHz)
Recommended Starting Frequency: ARFCN 975 (GSM 900) for better range and penetration
Configure YateBTS Core Settings
# Edit the main YateBTS configuration file
sudo nano /etc/yate/ybts.conf
Essential GSM configuration:
[GSM]
# Frequency configuration (GSM 900 MHz example)
arfcn=975
band=GSM900
# Cell identification parameters
mcc=001 # Mobile Country Code (use 001 for testing)
mnc=01 # Mobile Network Code (use 01 for testing)
lac=1 # Location Area Code
cell_id=1 # Cell ID (unique within LAC)
cell_name=MyYateBTS
# Power and transmission settings
tx_power=20 # Start with low power (20 dBm = 100 mW)
tx_attenuation=0 # Additional attenuation (0-31 dB)
# Timing and synchronization
timing_advance=0
ms_timing_advance=0
# Security and authentication
auth_required=true
cipher_required=false
Configuration Parameters Explained
ARFCN: Absolute Radio Frequency Channel Number - determines your operating frequency
MCC/MNC: Mobile Country/Network Code - identifies your network to phones
TX Power: Transmission power - start low and increase gradually
Cell Name: Network name displayed on phones
Configure SIM Card Database
# Create and edit SIM card configuration
sudo nano /etc/yate/sims.conf
Add your first test SIM card:
[sim1]
# Basic SIM information
imsi=001010123456789 # International Mobile Subscriber Identity
msisdn=1234567890 # Phone number (MSISDN)
# Authentication keys (get from SIM card)
ki=1234567890abcdef1234567890abcdef # Authentication key
opc=1234567890abcdef1234567890abcdef # Operator variant key
# SIM card type and capabilities
type=2g # 2G SIM card
pin_required=false # PIN not required
puk_attempts=3 # PUK attempts allowed
# Service permissions
voice_enabled=true # Voice calls allowed
sms_enabled=true # SMS messaging allowed
data_enabled=false # Data services disabled (2G only)
⚠️ SIM Card Security
KI and OPC Keys: These are sensitive cryptographic keys. Never share them publicly.
Testing Only: Use dedicated test SIM cards, not your personal phone SIM.
Backup: Keep secure backups of your SIM configuration files.
Configure BladeRF Mini A4
# Check BladeRF device detection
bladeRF-cli --probe
# Configure BladeRF settings
sudo nano /etc/yate/bladerf.conf
BladeRF configuration:
[bladerf]
# Device selection
device=0 # First BladeRF device
# Sample rate and bandwidth
sample_rate=13000000 # 13 MHz sample rate
bandwidth=10000000 # 10 MHz bandwidth
# Gain settings
rx_gain=20 # Receive gain (0-60 dB)
tx_gain=20 # Transmit gain (0-60 dB)
# Calibration
dc_calibration=true # Enable DC calibration
iq_calibration=true # Enable IQ calibration
# Antenna settings
antenna=TX/RX # Use TX/RX antenna port
Configure LimeSDR Mini (Alternative)
⚠️ LimeSDR Mini Setup
LimeSDR Mini requires additional driver installation and configuration. This section is for users who chose LimeSDR Mini instead of BladeRF Mini A4.
Step 1: Install LimeSuite drivers
# Install dependencies
sudo apt update
sudo apt install -y git cmake build-essential libsqlite3-dev
# Clone and build LimeSuite
git clone https://github.com/myriadrf/LimeSuite.git
cd LimeSuite
git checkout stable
mkdir builddir && cd builddir
cmake ../
make -j4
sudo make install
sudo ldconfig
Step 2: Install SoapySDR
# Install SoapySDR
sudo apt install -y soapysdr-tools soapysdr-module-lms7
# Test LimeSDR Mini detection
SoapySDRUtil --probe="driver=lime"
SoapySDRUtil --info
Step 3: Configure udev rules
# Create udev rule for LimeSDR Mini
sudo tee /etc/udev/rules.d/64-limesuite.rules << 'EOF'
SUBSYSTEM=="usb", ATTRS{idVendor}=="1d50", ATTRS{idProduct}=="6108", MODE="666"
SUBSYSTEM=="usb", ATTRS{idVendor}=="0403", ATTRS{idProduct}=="601f", MODE="666"
EOF
# Reload udev rules
sudo udevadm control --reload-rules
sudo udevadm trigger
Step 4: Test LimeSDR Mini
# Check device detection
LimeUtil --find
# Test device connection
LimeUtil --make=LimeSDR-Mini --info
# Run self test (optional)
LimeUtil --make=LimeSDR-Mini --test
LimeSDR Mini YateBTS configuration:
# Edit YateBTS configuration for LimeSDR Mini
sudo nano /etc/yate/ybts.conf
# Add LimeSDR Mini specific settings:
[transceiver]
radiodevice=soapy
radio_args=driver=lime,soapy=0
[soapy]
# Sample rate (must match LimeSDR Mini capabilities)
sample_rate=13000000
# Bandwidth
bandwidth=10000000
# Gain settings
rx_gain=30
tx_gain=30
# Channel configuration
channels=1
✅ LimeSDR Mini Configuration Tips
- Sample Rate: Use 13MHz for GSM compatibility
- Gain Settings: Start with moderate gains (30dB) and adjust
- Bandwidth: 10MHz bandwidth works well for GSM
- Calibration: LimeSDR Mini auto-calibrates on startup
- Antennas: Connect to TX/RX ports with uFL to SMA adapters
Configure Web Management Interface
# Configure Apache virtual host
sudo nano /etc/apache2/sites-available/yatebts.conf
Apache configuration:
<VirtualHost *:80>
ServerName yatebts.local
DocumentRoot /var/www/yatebts
# Enable PHP processing
<Directory /var/www/yatebts>
AllowOverride All
Require all granted
</Directory>
# Enable mod_rewrite
RewriteEngine On
# Security headers
Header always set X-Content-Type-Options nosniff
Header always set X-Frame-Options DENY
Header always set X-XSS-Protection "1; mode=block"
</VirtualHost>
# Enable the site and restart Apache
sudo a2ensite yatebts
sudo a2enmod rewrite headers
sudo systemctl restart apache2
Configure System Services
# Configure YateBTS systemd service
sudo nano /etc/systemd/system/yatebts.service
Service configuration:
[Unit]
Description=YateBTS GSM Base Station
After=network.target bladerf.service
Wants=bladerf.service
[Service]
Type=simple
User=yatebts
Group=yatebts
WorkingDirectory=/opt/yatebts
ExecStart=/opt/yatebts/bin/yatebts
ExecReload=/bin/kill -HUP $MAINPID
Restart=always
RestartSec=5
# Security settings
NoNewPrivileges=true
PrivateTmp=true
ProtectSystem=strict
ProtectHome=true
[Install]
WantedBy=multi-user.target
🛡️ Secure Your GSM Network Infrastructure
Professional compliance and security management for telecommunications systems
80% Less Compliance Work
Automate evidence collection for DORA, NIS2, ISO 27001, and SOC 2 frameworks
Save €60K+ Annually
Cut compliance costs without compromising security standards
24/7 Audit Ready
Continuous monitoring and automated reporting for GSM infrastructure
Why CyberUpgrade for YateBTS?
- ✅ Automated vulnerability scanning for SDR devices
- ✅ Compliance management for telecommunications regulations
- ✅ Expert CISO guidance for network security
- ✅ Risk management for BladeRF and Raspberry Pi infrastructure
🚀 Step 4: Start Your BTS
Start YateBTS Service
# Start the YateBTS service
sudo systemctl start yatebts
# Enable auto-start on boot
sudo systemctl enable yatebts
# Check service status
sudo systemctl status yatebts
Start Web Interface
# Start Apache web server
sudo systemctl start apache2
sudo systemctl enable apache2
# Check web interface
curl http://localhost/yatebts
Test Your BTS
Connect Test Phones:
- Power on test phones
- Search for networks manually
- Select your network (should appear as "MyYateBTS")
- Enter PIN if required
Verify Connections:
# Check active connections
sudo journalctl -u yatebts -f
# Check registered SIMs
curl http://localhost/yatebts/api/sims
# Check system status
curl http://localhost/yatebts/api/status
🎉 Congratulations!
You've successfully set up your first YateBTS GSM BTS! You now have a working GSM Base Transceiver Station with web management interface.
📚 Next Steps
Explore Advanced Features
- Multiple SIM cards
- Different frequencies
- Power optimization
- Performance tuning
Frequently Asked Questions
To build a portable GSM base station with RFS-Portable-BTS, you need:
- Raspberry Pi 4 8GB - Main processing unit ($75-85)
- BladeRF Mini A4 SDR - Software Defined Radio ($220-250)
- 32GB+ MicroSD Card - For Ubuntu 22.04 LTS ($15-25)
- USB-C Power Supply - 3A minimum for stable operation ($15-20)
- USB 3.0 Cable - For BladeRF connection ($10-15)
Total cost: approximately $335-395 for a complete portable GSM testing platform.
The complete setup process takes approximately 3-4 hours for beginners:
- 30 minutes: Hardware assembly and Ubuntu installation
- 45 minutes: System updates and dependency installation
- 90 minutes: YateBTS compilation and installation
- 45 minutes: Configuration and testing
Experienced users can complete the setup in approximately 2 hours.
Operating a GSM base station requires proper authorization:
- Licensed Use: Obtain appropriate radio frequency licenses from your local telecommunications authority
- Educational/Research: Many countries allow unlicensed operation for educational purposes with power restrictions
- Private Testing: Use in shielded environments or with dummy loads for security testing
- Emergency Services: Some jurisdictions allow emergency communication use
Always check local regulations before operating any radio frequency equipment.
The RFS-Portable-BTS supports a wide range of mobile devices:
- 2G/GSM Phones: All standard GSM devices (900/1800 MHz)
- 3G/UMTS Devices: With additional configuration
- Smartphones: Android and iOS devices in 2G fallback mode
- IoT Devices: NB-IoT and GSM-based sensors and trackers
- Testing Devices: Samsung S5, specialized security testing phones
Device compatibility depends on frequency bands and network configuration.