detecting-deepfake-audio-in-vishing-attacks skill (Anthropic-Cybersecurity-Skills)

From Public Agent Wiki

What it does. Detect AI-generated deepfake audio used in voice phishing (vishing) by extracting spectral features (MFCC, spectral centroid, spectral contrast, zero-crossing rate) and classifying samples with machine learning models, supporting batch audio analysis, confidence scoring, and forensic reporting. Use for deepfake voice detection, vishing investigations, AI-generated speech analysis, voice cloning detection, or audio authenticity verification. Part of mukul975/Anthropic-Cybersecurity-Skills (817 security skills) (mukul975/Anthropic-Cybersecurity-Skills).
Upstream mukul975/Anthropic-Cybersecurity-Skills
Skill file skills/detecting-deepfake-audio-in-vishing-attacks/SKILL.md
License Apache-2.0 (skill folder LICENSE)
Author mukul975
Fetched 2026-09-10

Install

  • npx skills add mukul975/Anthropic-Cybersecurity-Skills --skill detecting-deepfake-audio-in-vishing-attacks, or copy the skill folder into ~/.claude/skills/detecting-deepfake-audio-in-vishing-attacks/.
  • Raw file: curl -sL https://raw.githubusercontent.com/mukul975/Anthropic-Cybersecurity-Skills/HEAD/skills/detecting-deepfake-audio-in-vishing-attacks/SKILL.md

SKILL.md (verbatim)

name: detecting-deepfake-audio-in-vishing-attacks
description: Detect AI-generated deepfake audio used in voice phishing (vishing) by extracting spectral features (MFCC, spectral centroid, spectral contrast, zero-crossing rate) and classifying samples with machine learning models, supporting batch audio analysis, confidence scoring, and forensic reporting. Use for deepfake voice detection, vishing investigations, AI-generated speech analysis, voice cloning detection, or audio authenticity verification.
domain: cybersecurity
subdomain: social-engineering-defense
tags:
- deepfake-detection
- vishing
- audio-forensics
- MFCC
- spectral-analysis
- voice-cloning
version: 1.0.0
author: mukul975
license: Apache-2.0
atlas_techniques:
- AML.T0088
- AML.T0043
- AML.T0018
- AML.T0052
nist_ai_rmf:
- MEASURE-2.7
- GOVERN-6.2
- MAP-5.2
- MEASURE-2.5
- MAP-5.1
d3fend_techniques:
- Sender Reputation Analysis
- Content Validation
- Message Analysis
- User Behavior Analysis
- Identifier Analysis
nist_csf:
- PR.AT-01
- DE.CM-09
- RS.CO-02
mitre_attack:
- T1078
- T1190
- T1059
- T1566
- T1598
mitre_f3:
  version: '1.1'
  tactics:
  - reconnaissance
  - initial-access
  - stealth
  - monetization
  techniques:
  - id: F1032
    name: Impersonate Official
    tactic: initial-access
    source: f3
  - id: F1031
    name: Impersonate Account Holder
    tactic: initial-access
    source: f3
  - id: F1040
    name: Phone Number Spoofing
    tactic: stealth
    source: f3
  - id: F1034
    name: Interactive Voice Response Mapping
    tactic: reconnaissance
    source: f3
  - id: F1025.003
    name: 'Electronic Funds Transfer: Wire Transfer'
    tactic: monetization
    source: f3

Detecting Deepfake Audio in Vishing Attacks

When to Use

  • A suspected vishing call used an AI-cloned executive voice to authorize a wire transfer
  • Security operations received a voicemail that sounds like the CEO but the tone seems off
  • Incident response needs to determine whether a recorded phone call contains synthetic speech
  • Fraud investigation requires forensic proof that audio was AI-generated
  • Red team exercises use voice cloning and blue team needs detection capability

Do not use for text-based phishing (email/SMS); use email header analysis or URL detonation tools instead.

Prerequisites

  • Python 3.9+ with librosa, numpy, scikit-learn, and scipy installed
  • Audio samples in WAV, MP3, or FLAC format (mono or stereo, any sample rate)
  • Reference corpus of known genuine voice samples for the targeted individual (optional but improves accuracy)
  • FFmpeg installed for audio format conversion (librosa dependency)
  • Minimum 3 seconds of audio for reliable feature extraction

Workflow

Step 1: Audio Preprocessing

Normalize and prepare audio samples for feature extraction:

import librosa
import numpy as np

# Load audio, resample to 16kHz mono
y, sr = librosa.load("suspect_call.wav", sr=16000, mono=True)

# Trim silence from beginning and end
y_trimmed, _ = librosa.effects.trim(y, top_db=25)

# Normalize amplitude to [-1, 1]
y_norm = y_trimmed / np.max(np.abs(y_trimmed))

Audio preprocessing ensures consistent feature extraction across different recording conditions, microphones, and codec artifacts.

Step 2: Extract Spectral Features

Extract the feature set that distinguishes real from synthetic speech:

Mel-Frequency Cepstral Coefficients (MFCCs):

# Extract 20 MFCCs + delta and delta-delta
mfccs = librosa.feature.mfcc(y=y_norm, sr=sr, n_mfcc=20)
mfcc_delta = librosa.feature.delta(mfccs)
mfcc_delta2 = librosa.feature.delta(mfccs, order=2)

MFCCs capture the spectral envelope of speech, representing how the vocal tract shapes sound. Deepfake audio often shows unnatural smoothness in higher-order MFCCs because neural vocoders approximate but do not perfectly replicate the acoustic resonance of a physical vocal tract.

Spectral Features:

spectral_centroid = librosa.feature.spectral_centroid(y=y_norm, sr=sr)
spectral_bandwidth = librosa.feature.spectral_bandwidth(y=y_norm, sr=sr)
spectral_contrast = librosa.feature.spectral_contrast(y=y_norm, sr=sr)
spectral_rolloff = librosa.feature.spectral_rolloff(y=y_norm, sr=sr)
zero_crossing_rate = librosa.feature.zero_crossing_rate(y_norm)

Key indicators of deepfake audio:

  • Reduced spectral contrast in the 4-8 kHz range (vocoders compress high-frequency detail)
  • Abnormally consistent spectral centroid over time (real speech has natural variation)
  • Lower zero-crossing rate variance (synthetic speech lacks micro-perturbations)
  • Missing or attenuated formant transitions during consonant-vowel boundaries

Step 3: Build Feature Vector and Classify

Aggregate frame-level features into a fixed-length vector and classify:

from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
from sklearn.model_selection import cross_val_score

def build_feature_vector(y, sr):
    features = []
    mfccs = librosa.feature.mfcc(y=y, sr=sr, n_mfcc=20)
    for coeff in mfccs:
        features.extend([np.mean(coeff), np.std(coeff), np.min(coeff), np.max(coeff)])
    for feat_fn in [librosa.feature.spectral_centroid,
                    librosa.feature.spectral_bandwidth,
                    librosa.feature.spectral_rolloff,
                    librosa.feature.zero_crossing_rate]:
        feat = feat_fn(y=y, sr=sr) if feat_fn != librosa.feature.zero_crossing_rate else feat_fn(y)
        features.extend([np.mean(feat), np.std(feat), np.min(feat), np.max(feat)])
    contrast = librosa.feature.spectral_contrast(y=y, sr=sr)
    for band in contrast:
        features.extend([np.mean(band), np.std(band)])
    return np.array(features)

Classification uses an ensemble approach: Random Forest for robustness and Gradient Boosting for accuracy, with a voting mechanism to reduce false positives.

Step 4: Temporal Artifact Analysis

Examine time-domain artifacts that neural vocoders leave behind:

# Pitch stability analysis - deepfakes often have unnaturally stable F0
f0, voiced_flag, voiced_probs = librosa.pyin(y_norm, fmin=50, fmax=500, sr=sr)
f0_clean = f0[~np.isnan(f0)]
pitch_std = np.std(f0_clean) if len(f0_clean) > 0 else 0
pitch_jitter = np.mean(np.abs(np.diff(f0_clean))) if len(f0_clean) > 1 else 0

Real human speech exhibits natural pitch jitter (micro-variations in fundamental frequency) and shimmer (amplitude perturbations). Deepfake audio generated by Tacotron 2, VALL-E, or ElevenLabs typically shows reduced jitter and shimmer compared to genuine speech.

Step 5: Spectrogram Visual Inspection

Generate spectrograms for manual forensic review:

import librosa.display
import matplotlib.pyplot as plt

fig, axes = plt.subplots(2, 2, figsize=(14, 10))
librosa.display.specshow(librosa.power_to_db(librosa.feature.melspectrogram(y=y_norm, sr=sr)),
                         sr=sr, ax=axes[0, 0], x_axis='time', y_axis='mel')
axes[0, 0].set_title('Mel Spectrogram')
librosa.display.specshow(mfccs, sr=sr, ax=axes[0, 1], x_axis='time')
axes[0, 1].set_title('MFCCs')

Visual inspection reveals banding artifacts in mel spectrograms, unnatural energy cutoffs above the vocoder's frequency ceiling, and periodic noise patterns in the high-frequency range that are characteristic of neural speech synthesis.

Step 6: Generate Forensic Report

Compile findings into an actionable report:

DEEPFAKE AUDIO ANALYSIS REPORT
================================
File:              suspect_executive_call.wav
Duration:          47.3 seconds
Sample Rate:       16000 Hz
Analysis Date:     2026-03-19

CLASSIFICATION RESULT
Verdict:           LIKELY DEEPFAKE (confidence: 94.2%)
Ensemble Score:    RF=0.91, GBT=0.97, Avg=0.94

FEATURE ANOMALIES DETECTED
- MFCC variance in coefficients 13-20: 62% below genuine baseline
- Spectral contrast (4-8 kHz): 0.23 (genuine avg: 0.41)
- Pitch jitter: 0.8 Hz (genuine avg: 2.4 Hz)
- Zero-crossing rate std: 0.003 (genuine avg: 0.011)

SPECTROGRAM ARTIFACTS
- Energy cutoff above 7.8 kHz (consistent with neural vocoder ceiling)
- Banding pattern at 50ms intervals in mel spectrogram
- Missing formant transitions at 12.4s, 23.1s, 35.7s timestamps

RECOMMENDATION
High confidence of AI-generated audio. Recommend out-of-band
verification with the purported speaker. Preserve original audio
file with chain of custody documentation for potential legal action.

Key Concepts

Term Definition
MFCC Mel-Frequency Cepstral Coefficients; representation of the short-term power spectrum on a mel (perceptual) frequency scale
Spectral Centroid Weighted mean of frequencies present in the signal; indicates perceived brightness of a sound
Spectral Contrast Difference in amplitude between peaks and valleys in the spectrum across frequency sub-bands
Vocoder Signal processing component that synthesizes audio waveforms from acoustic features; used in TTS and voice cloning
Pitch Jitter Cycle-to-cycle variation in fundamental frequency; natural in human speech, reduced in synthetic speech
Vishing Voice phishing; social engineering attack conducted via phone calls, increasingly using AI-cloned voices
Formant Resonant frequencies of the vocal tract that define vowel sounds; transitions between formants are difficult for AI to replicate perfectly

Tools & Systems

  • librosa: Python library for audio analysis providing MFCC, spectral feature extraction, and spectrogram generation
  • scikit-learn: Machine learning library used for Random Forest and Gradient Boosting classification
  • Resemblyzer: Speaker embedding library for comparing voice identity between known genuine and suspect samples
  • Speechbrain: Deep learning toolkit for speech processing with pretrained deepfake detection models
  • Praat: Phonetics software for detailed pitch, jitter, and shimmer analysis of speech samples
  • FFmpeg: Audio format conversion and preprocessing utility required by librosa

Common Scenarios

Scenario: Executive Impersonation Wire Transfer Fraud

Context: CFO receives a phone call appearing to be from the CEO requesting an urgent wire transfer of $2.3M. The call came from an unknown number but the voice sounded identical to the CEO. IT security was able to obtain a recording of the call from the phone system.

Approach:

  1. Extract the audio from the phone system recording and convert to WAV at 16kHz
  2. Run MFCC and spectral feature extraction on the suspect audio
  3. Compare against known genuine CEO voice samples from recorded meetings
  4. Analyze pitch jitter and shimmer against human speech baselines
  5. Classify using the trained ensemble model and generate confidence score
  6. Produce forensic report with spectrogram evidence for legal/compliance

Pitfalls:

  • Phone codec compression (G.711, AMR) degrades audio quality and can mask deepfake artifacts
  • Short audio clips (under 3 seconds) produce unreliable feature statistics
  • Background noise from the call environment can reduce classification accuracy
  • Highly sophisticated voice cloning (e.g., fine-tuned VALL-E with 30+ minutes of training data) may evade basic feature analysis
  • Genuine speech transmitted through VoIP may exhibit spectral artifacts similar to deepfakes

Other files in this skill

references/api-reference.md (verbatim)

API Reference: Deepfake Audio Detection

librosa - Audio Feature Extraction

Loading and Preprocessing

import librosa

# Load audio with resampling
y, sr = librosa.load("file.wav", sr=16000, mono=True)

# Trim silence (top_db = threshold in dB below peak)
y_trimmed, index = librosa.effects.trim(y, top_db=25)

MFCC Extraction

# Extract n MFCCs per frame
mfccs = librosa.feature.mfcc(y=y, sr=sr, n_mfcc=20, hop_length=512, n_fft=2048)
# Returns: numpy array of shape (n_mfcc, num_frames)

# Delta (first derivative) and delta-delta (second derivative)
mfcc_delta = librosa.feature.delta(mfccs)
mfcc_delta2 = librosa.feature.delta(mfccs, order=2)

Spectral Features

# Spectral centroid - "center of mass" of the spectrum
centroid = librosa.feature.spectral_centroid(y=y, sr=sr)

# Spectral bandwidth - weighted standard deviation of frequencies
bandwidth = librosa.feature.spectral_bandwidth(y=y, sr=sr)

# Spectral contrast - difference between peaks and valleys per sub-band
contrast = librosa.feature.spectral_contrast(y=y, sr=sr)
# Returns: shape (n_bands + 1, num_frames), default 7 bands

# Spectral rolloff - frequency below which 85% of energy is concentrated
rolloff = librosa.feature.spectral_rolloff(y=y, sr=sr)

# Spectral flatness - measure of noisiness vs tonality (0=tonal, 1=noise)
flatness = librosa.feature.spectral_flatness(y=y)

# Zero-crossing rate - rate of sign changes in the signal
zcr = librosa.feature.zero_crossing_rate(y, hop_length=512)

Pitch Estimation (pYIN Algorithm)

# Fundamental frequency estimation using probabilistic YIN
f0, voiced_flag, voiced_probs = librosa.pyin(
    y, fmin=50, fmax=500, sr=sr, hop_length=512
)
# f0: numpy array with NaN for unvoiced frames
# voiced_flag: boolean array
# voiced_probs: probability of voicing per frame

Mel Spectrogram

# Compute mel-scaled spectrogram
mel_spec = librosa.feature.melspectrogram(y=y, sr=sr, n_mels=128)

# Convert to dB scale for visualization
mel_db = librosa.power_to_db(mel_spec, ref=np.max)

Onset Detection

# Onset strength envelope
onset_env = librosa.onset.onset_strength(y=y, sr=sr)

# Tempo estimation
tempo = librosa.feature.tempo(onset_envelope=onset_env, sr=sr)

scikit-learn - ML Classification

Random Forest Classifier

from sklearn.ensemble import RandomForestClassifier

rf = RandomForestClassifier(
    n_estimators=200,    # number of trees
    max_depth=15,        # max tree depth
    random_state=42,
    n_jobs=-1            # use all CPU cores
)
rf.fit(X_train, y_train)
proba = rf.predict_proba(X_test)  # returns [P(genuine), P(deepfake)]

Gradient Boosting Classifier

from sklearn.ensemble import GradientBoostingClassifier

gbt = GradientBoostingClassifier(
    n_estimators=150,
    max_depth=5,
    learning_rate=0.1,
    random_state=42
)
gbt.fit(X_train, y_train)
proba = gbt.predict_proba(X_test)

Feature Scaling

from sklearn.preprocessing import StandardScaler

scaler = StandardScaler()
X_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

Cross-Validation

from sklearn.model_selection import cross_val_score

scores = cross_val_score(model, X, y, cv=5, scoring="accuracy")
print(f"Accuracy: {scores.mean():.3f} (+/- {scores.std():.3f})")

Datasets for Training

ASVspoof Challenge

  • ASVspoof 2019 LA: Logical access partition with TTS and voice conversion attacks
  • ASVspoof 2021: Extended with telephony and compression conditions
  • URL: https://www.asvspoof.org/
  • Format: FLAC audio files with protocol files mapping utterance IDs to labels

FakeAVCeleb

In-the-Wild Dataset

Feature Importance for Deepfake Detection

Based on research from IEEE and Springer publications:

Feature Importance Why
MFCC 13-20 variance High Neural vocoders smooth high-order cepstral coefficients
Pitch jitter High TTS systems produce unnaturally stable F0 contours
Spectral contrast (4-8kHz) Medium Vocoders compress high-frequency spectral detail
ZCR standard deviation Medium Synthetic speech lacks micro-perturbations
Spectral centroid CV Medium Deepfakes have more consistent spectral center
MFCC delta-delta Medium Second-order dynamics are harder for AI to replicate
Spectral flatness Low Slightly elevated in vocoder artifacts
RMS energy variance Low Some vocoders produce smoother energy contours

CLI Usage Examples

# Analyze a single audio file
python agent.py analyze suspect_call.wav

# Analyze with trained model
python agent.py analyze suspect_call.wav --model deepfake_model.joblib -o result.json

# Batch analyze a directory
python agent.py batch /path/to/audio/samples/ -o batch_results.json

# Train a model from labeled data
python agent.py train --genuine /data/genuine/ --deepfake /data/deepfake/ -o model.joblib

# Extract features only (for custom analysis)
python agent.py features suspect_call.wav -o features.json

Back to mukul975/Anthropic-Cybersecurity-Skills (817 security skills) or Agent skills.