sensorkit — independently scanned and version-tracked by SaferSkills.
SaferSkills independently audited sensorkit (Agent Skill) and scored it 45/100 (orange). The audit ran 55 deterministic rules across Security, Supply Chain, Maintenance, Transparency, and Community; it found 2 high-severity and 0 lower-severity findings. The full rule-by-rule trace and per-finding evidence are below. Free, methodology-open.
Findings & checks · 2 flagged
A base64 string of 128+ characters appears in a documentation file. Encoded prompt injection hides the hostile instruction in base64 — invisible to keyword filters — and relies on the agent's ability to decode it at runtime. There is no normal authoring reason to embed a multi-hundred-byte base64 blob in skill docs.
*.sig, SIGNATURES) outside the documentation.Every scanned point with the score it earned and what moved between them.
First recorded scan — no prior version to compare against.
The primary manifest — the file an agent reads to learn what this artifact does.
Choose the exact SRSensor and verify its individual availability. Use CoreMotion for ordinary motion/activity features and HealthKit for health records and workouts.
SensorKit enables research apps to record and fetch sensor data across iPhone and Apple Watch. The framework requires:
com.apple.developer.sensorkit.reader.allowonly for approved studies.
SensorKit capability enabled.
sheet that users approve per-sensor.
An app can access up to 7 days of prior recorded data for an active sensor.
Add the SensorKit reader entitlement to a .entitlements file. List only the sensors Apple approved for the study. Common entitlement values include:
<key>com.apple.developer.sensorkit.reader.allow</key>
<array>
<string>ambient-light-sensor</string>
<string>motion-accelerometer</string>
<string>device-usage</string>
<string>keyboard-metrics</string>
</array>Load the Entitlement and Usage-Detail Catalog when selecting the exact entitlement string and NSSensorKitUsageDetail key for each approved sensor. Recheck specialized sensors against their individual SRSensor pages.
For manual signing, set Code Signing Entitlements to the entitlements file, Code Signing Identity to Apple Developer, Code Signing Style to Manual, and Provisioning Profile to the explicit profile with SensorKit capability.
Three keys are required:
<!-- Study purpose shown in the authorization sheet -->
<key>NSSensorKitUsageDescription</key>
<string>This study monitors activity patterns for sleep research.</string>
<!-- Link to your study's privacy policy -->
<key>NSSensorKitPrivacyPolicyURL</key>
<string>https://example.com/privacy-policy</string>
<!-- Per-sensor usage explanations -->
<key>NSSensorKitUsageDetail</key>
<dict>
<key>SRSensorUsageMotion</key>
<dict>
<key>Description</key>
<string>Measures physical activity levels during the study.</string>
<key>Required</key>
<true/>
</dict>
<key>SRSensorUsageAmbientLightSensor</key>
<dict>
<key>Description</key>
<string>Records ambient light to assess sleep environment.</string>
</dict>
</dict>If Required is true and the user denies that sensor, the system warns them that the study needs it and offers a chance to reconsider.
Use the exact usage-detail dictionary for each requested sensor. Load the Entitlement and Usage-Detail Catalog when mapping sensors beyond the motion and ambient-light examples above.
Request authorization for the sensors your study needs. The system shows the Research Sensor & Usage Data sheet on first request.
import SensorKit
let reader = SRSensorReader(sensor: .ambientLightSensor)
// Request authorization for multiple sensors at once
SRSensorReader.requestAuthorization(
sensors: [.ambientLightSensor, .accelerometer, .keyboardMetrics]
) { error in
if let error {
print("Authorization request failed: \(error)")
}
}Use one status handler both for the initial check and delegate changes:
private func applyAuthorizationStatus(
_ status: SRAuthorizationStatus,
to reader: SRSensorReader
) {
switch status {
case .authorized:
reader.startRecording()
case .denied:
reader.stopRecording()
// Direct the user to Settings > Privacy > Research Sensor & Usage Data.
case .notDetermined:
break // Request authorization first.
@unknown default:
break
}
}
applyAuthorizationStatus(reader.authorizationStatus, to: reader)
func sensorReader(_ reader: SRSensorReader, didChange authorizationStatus: SRAuthorizationStatus) {
applyAuthorizationStatus(authorizationStatus, to: reader)
}Load the Sensor Catalog to map each SRSensor to its sample type. Request only sensors approved for the study and recheck the selected sensor's availability and usage-detail key.
SRSensorReader is the central class for accessing sensor data. Each instance reads from a single sensor.
import SensorKit
// Create a reader for one sensor
let lightReader = SRSensorReader(sensor: .ambientLightSensor)
let keyboardReader = SRSensorReader(sensor: .keyboardMetrics)
// Assign delegate to receive callbacks
lightReader.delegate = self
keyboardReader.delegate = selfThe reader communicates through SRSensorReaderDelegate. Load the Delegate Method Catalog when wiring the complete authorization, recording, device-fetch, and sample-fetch lifecycle.
// Begin recording -- sensor stays active as long as any app has a stake
reader.startRecording()
// Stop recording -- framework deactivates the sensor when
// no app or system process is using it
reader.stopRecording()Build an SRFetchRequest with a time range and target device, then pass it to the reader:
let request = SRFetchRequest()
request.device = SRDevice.current
request.from = SRAbsoluteTime(CFAbsoluteTimeGetCurrent() - 86400 * 2) // 2 days ago
request.to = SRAbsoluteTime.current()
reader.fetch(request)Receive results through the delegate:
func sensorReader(
_ reader: SRSensorReader,
fetching request: SRFetchRequest,
didFetchResult result: SRFetchResult<AnyObject>
) -> Bool {
let timestamp = result.timestamp
switch reader.sensor {
case .ambientLightSensor:
if let sample = result.sample as? SRAmbientLightSample {
let lux = sample.lux
let chromaticity = sample.chromaticity
let placement = sample.placement
processSample(lux: lux, chromaticity: chromaticity, at: timestamp)
}
case .keyboardMetrics:
if let sample = result.sample as? SRKeyboardMetrics {
let words = sample.totalWords
let speed = sample.typingSpeed
processKeyboard(words: words, speed: speed, at: timestamp)
}
case .deviceUsageReport:
if let sample = result.sample as? SRDeviceUsageReport {
let wakes = sample.totalScreenWakes
let unlocks = sample.totalUnlocks
processUsage(wakes: wakes, unlocks: unlocks, at: timestamp)
}
default:
break
}
return true // Return true to continue receiving results
}
func sensorReader(_ reader: SRSensorReader, didCompleteFetch request: SRFetchRequest) {
print("Fetch complete for \(reader.sensor)")
}
func sensorReader(
_ reader: SRSensorReader,
fetching request: SRFetchRequest,
failedWithError error: any Error
) {
print("Fetch failed: \(error)")
}Cast result.sample to the sample shape for the reader's sensor. Some streams return one object per result, while recorded motion, ECG, PPG, and ambient pressure streams can return arrays of recorded samples.
SensorKit imposes a 24-hour holding period on newly recorded data. Fetch requests whose time range overlaps this period return no results. Design data collection workflows around this delay.
SRDevice identifies the hardware source for sensor samples. Use it to distinguish data from iPhone versus Apple Watch.
// Get the current device
let currentDevice = SRDevice.current
print("Model: \(currentDevice.model)")
print("System: \(currentDevice.systemName) \(currentDevice.systemVersion)")
// Fetch all available devices for a sensor
reader.fetchDevices()Handle fetched devices through the delegate:
func sensorReader(_ reader: SRSensorReader, didFetch devices: [SRDevice]) {
for device in devices {
let request = SRFetchRequest()
request.device = device
request.from = SRAbsoluteTime(CFAbsoluteTimeGetCurrent() - 86400)
request.to = SRAbsoluteTime.current()
reader.fetch(request)
}
}
func sensorReader(_ reader: SRSensorReader, fetchDevicesDidFailWithError error: any Error) {
print("Failed to fetch devices: \(error)")
}| Property | Type | Description |
|---|---|---|
model | String | User-defined device name |
name | String | Framework-defined device name |
systemName | String | OS name (iOS, watchOS) |
systemVersion | String | OS version |
productType | String | Hardware identifier |
current | SRDevice | Class property for the running device |
Obtain Apple's study approval, the sensor-specific entitlement values, and a matching manual provisioning profile before constructing production readers.
Apply the Data Holding Period; a fetch overlapping the hold is not proof that recording failed.
Assign the delegate before startRecording() or fetch(_:); results and failures arrive through delegate callbacks.
Add the exact Info.plist Configuration usage-detail entry for every requested sensor.
Distinguish at least .invalidEntitlement, .noAuthorization, .dataInaccessible, .fetchRequestInvalid, .promptDeclined, and unknown future codes. Load the Full Delegate Implementation for the complete switch and callback wiring.
com.apple.developer.sensorkit.reader.allow entitlement lists only needed sensorsNSSensorKitUsageDescription in Info.plist with clear study purposeNSSensorKitPrivacyPolicyURL in Info.plist with valid privacy policy URLNSSensorKitUsageDetail entries for every requested sensorRequired key set appropriately for essential vs. optional sensorsstartRecording() or fetch(_:)SRError codes handled in all failure delegate methodsfetchDevices() used to discover available devices before fetchingstopRecording() called when data collection is completesensorReader(_:fetching:didFetchResult:) returns true to continue or false to stop~30 seconds. Free. No account. Every finding cites a rule and a line of evidence.