Tamper-resistant block timing: SCBlockClock + trusted-time verification

Common/SCXPCClient.h

@@ -22,6 +22,7 @@ NS_ASSUME_NONNULL_BEGIN
 - (void)startBlockWithControllingUID:(uid_t)controllingUID blocklist:(NSArray<NSString*>*)blocklist isAllowlist:(BOOL)isAllowlist endDate:(NSDate*)endDate blockSettings:(NSDictionary*)blockSettings reply:(void(^)(NSError* error))reply;
 - (void)updateBlocklist:(NSArray<NSString*>*)newBlocklist reply:(void(^)(NSError* error))reply;
 - (void)updateBlockEndDate:(NSDate*)newEndDate reply:(void(^)(NSError* error))reply;
+- (void)getBlockUnlockGateStateWithReply:(void(^)(BOOL waiting, NSDate* _Nullable lastAttemptAt, NSString* _Nullable errorReason))reply;
 
 @end
 

Common/SCXPCClient.m

@@ -329,6 +329,20 @@ - (void)updateBlocklist:(NSArray<NSString*>*)newBlocklist reply:(void(^)(NSError
     }];
 }
 
+- (void)getBlockUnlockGateStateWithReply:(void(^)(BOOL waiting, NSDate* lastAttemptAt, NSString* errorReason))reply {
+    [self connectAndExecuteCommandBlock:^(NSError * connectError) {
+        if (connectError != nil) {
+            NSLog(@"Failed to get unlock gate state with connection error: %@", connectError);
+            reply(NO, nil, connectError.localizedDescription);
+        } else {
+            [[self.daemonConnection remoteObjectProxyWithErrorHandler:^(NSError * proxyError) {
+                NSLog(@"Failed to get unlock gate state with remote object proxy error: %@", proxyError);
+                reply(NO, nil, proxyError.localizedDescription);
+            }] getBlockUnlockGateStateWithReply: reply];
+        }
+    }];
+}
+
 - (void)updateBlockEndDate:(NSDate*)newEndDate reply:(void(^)(NSError* error))reply {
     [self connectAndExecuteCommandBlock:^(NSError * connectError) {
         if (connectError != nil) {

Common/Utility/SCBlockClock.h

@@ -0,0 +1,60 @@
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// Tamper-resistant block-elapsed-time accounting.
+/// Combines mach_continuous_time() with a periodic on-disk checkpoint so that
+/// changing the system clock with `sudo date` cannot end a block early.
+///
+/// All mutating class methods (recordBlockStart, tickCheckpoint) must be invoked
+/// serialized — e.g. from the daemon's main runloop. SCSettings @synchronized
+/// protects each get/set leg, but not the combined read-modify-write pattern.
+@interface SCBlockClock : NSObject
+
+/// Called once at block start. Writes the BlockTimekeeping dictionary into SCSettings.
++ (void)recordBlockStartWithDuration:(NSTimeInterval)durationSeconds;
+
+/// As above, but also persists enough block-config to rebuild the block if SCSettings
+/// is tampered with (e.g. the stock SelfControl Killer running resetAllSettingsToDefaults).
+/// BlockTimekeeping is intentionally NOT in defaultSettingsDict, so it survives that reset.
++ (void)recordBlockStartWithDuration:(NSTimeInterval)durationSeconds
+                           blocklist:(nullable NSArray<NSString*>*)blocklist
+                         isAllowlist:(BOOL)isAllowlist
+                             endDate:(nullable NSDate*)endDate;
+
+/// Block-config previously stashed by recordBlockStart, for the daemon's tampering-
+/// recovery path. Returns nil if no block is recorded or the metadata was never stored.
++ (nullable NSArray<NSString*>*)savedActiveBlocklist;
++ (BOOL)savedActiveBlockAsWhitelist;
++ (nullable NSDate*)savedBlockEndDate;
+
+/// Erase all block-tracking state. Call after a legitimate block end so a future
+/// checkupBlock does not misread stale data as evidence of tampering.
++ (void)clearAllBlockState;
+
+/// Called every ~30 s by the daemon. Updates elapsedSecondsAccumulated and the
+/// last-checkpoint values, using the smaller of the wall-clock delta and the
+/// monotonic delta. A negative wall-clock delta credits zero.
++ (void)tickCheckpoint;
+
+/// Total real seconds elapsed since the block started. Returns 0 if no block.
++ (NSTimeInterval)elapsedSecondsForCurrentBlock;
+
+/// YES iff elapsedSecondsForCurrentBlock >= the recorded duration.
++ (BOOL)blockDurationHasElapsed;
+
+/// Recorded total block duration in seconds. Returns 0 if no block is recorded.
++ (NSTimeInterval)blockDurationSeconds;
+
+/// Seconds left until elapsedSecondsForCurrentBlock reaches blockDurationSeconds.
+/// Clamped at 0; returns 0 if no block is recorded.
++ (NSTimeInterval)remainingSecondsForCurrentBlock;
+
+#ifdef DEBUG
+/// Test-only override. Pass nil to clear.
++ (void)setBootSessionUUIDOverrideForTesting:(nullable NSString*)uuid;
+#endif
+
+@end
+
+NS_ASSUME_NONNULL_END

Common/Utility/SCBlockClock.m

@@ -0,0 +1,187 @@
+#import "SCBlockClock.h"
+#import "SCSettings.h"
+#import <mach/mach_time.h>
+#import <sys/sysctl.h>
+
+static NSString* const kBlockTimekeepingKey       = @"BlockTimekeeping";
+static NSString* const kBlockStartWallClockKey    = @"blockStartWallClock";
+static NSString* const kBlockStartContinuousKey   = @"blockStartContinuousTime";
+static NSString* const kBootSessionUUIDKey        = @"bootSessionUUID";
+static NSString* const kBlockDurationSecondsKey   = @"blockDurationSeconds";
+static NSString* const kElapsedAccumulatedKey     = @"elapsedSecondsAccumulated";
+static NSString* const kLastCheckpointWallKey     = @"lastCheckpointWallClock";
+static NSString* const kLastCheckpointContKey     = @"lastCheckpointContinuous";
+
+// Tamper-recovery fields. Mirrored from SCSettings at block start so the daemon
+// can reconstitute the block if the user wipes SCSettings (e.g. via the stock
+// SelfControl Killer). These keys live inside BlockTimekeeping, which is not in
+// defaultSettingsDict and therefore survives resetAllSettingsToDefaults.
+static NSString* const kSavedBlocklistKey         = @"savedActiveBlocklist";
+static NSString* const kSavedIsAllowlistKey       = @"savedActiveBlockAsWhitelist";
+static NSString* const kSavedEndDateKey           = @"savedBlockEndDate";
+
+static NSString* sBootUUIDOverride = nil;
+
+@implementation SCBlockClock
+
++ (NSString*)currentBootSessionUUID {
+    if (sBootUUIDOverride != nil) return sBootUUIDOverride;
+    struct timeval boottime;
+    size_t size = sizeof(boottime);
+    if (sysctlbyname("kern.boottime", &boottime, &size, NULL, 0) != 0) {
+        return @"unknown";
+    }
+    return [NSString stringWithFormat: @"%ld.%d", (long)boottime.tv_sec, boottime.tv_usec];
+}
+
+#ifdef DEBUG
++ (void)setBootSessionUUIDOverrideForTesting:(NSString*)uuid {
+    sBootUUIDOverride = [uuid copy];
+}
+#endif
+
++ (uint64_t)continuousNanos {
+    static mach_timebase_info_data_t tb;
+    static dispatch_once_t once;
+    dispatch_once(&once, ^{ mach_timebase_info(&tb); });
+    // mach_continuous_time() returns mach ticks; convert to nanoseconds via the
+    // platform timebase (numer/denom). On Apple Silicon ticks != nanoseconds.
+    return mach_continuous_time() * tb.numer / tb.denom;
+}
+
++ (void)recordBlockStartWithDuration:(NSTimeInterval)durationSeconds {
+    [self recordBlockStartWithDuration: durationSeconds
+                             blocklist: nil
+                           isAllowlist: NO
+                               endDate: nil];
+}
+
++ (void)recordBlockStartWithDuration:(NSTimeInterval)durationSeconds
+                           blocklist:(NSArray<NSString*>*)blocklist
+                         isAllowlist:(BOOL)isAllowlist
+                             endDate:(NSDate*)endDate {
+    NSDate* now = [NSDate date];
+    uint64_t cont = [self continuousNanos];
+    NSMutableDictionary* tk = [@{
+        kBlockStartWallClockKey:   now,
+        kBlockStartContinuousKey:  @(cont),
+        kBootSessionUUIDKey:       [self currentBootSessionUUID],
+        kBlockDurationSecondsKey:  @(durationSeconds),
+        kElapsedAccumulatedKey:    @(0.0),
+        kLastCheckpointWallKey:    now,
+        kLastCheckpointContKey:    @(cont),
+        kSavedIsAllowlistKey:      @(isAllowlist),
+    } mutableCopy];
+    if (blocklist != nil) tk[kSavedBlocklistKey] = blocklist;
+    if (endDate   != nil) tk[kSavedEndDateKey]   = endDate;
+    [[SCSettings sharedSettings] setValue: tk forKey: kBlockTimekeepingKey];
+}
+
++ (NSArray<NSString*>*)savedActiveBlocklist {
+    NSDictionary* tk = [self readTK];
+    NSArray* list = tk[kSavedBlocklistKey];
+    return [list isKindOfClass: [NSArray class]] ? list : nil;
+}
+
++ (BOOL)savedActiveBlockAsWhitelist {
+    NSDictionary* tk = [self readTK];
+    return [tk[kSavedIsAllowlistKey] boolValue];
+}
+
++ (NSDate*)savedBlockEndDate {
+    NSDictionary* tk = [self readTK];
+    NSDate* d = tk[kSavedEndDateKey];
+    return [d isKindOfClass: [NSDate class]] ? d : nil;
+}
+
++ (void)clearAllBlockState {
+    [[SCSettings sharedSettings] setValue: nil forKey: kBlockTimekeepingKey];
+}
+
++ (NSDictionary*)readTK {
+    return [[SCSettings sharedSettings] valueForKey: kBlockTimekeepingKey];
+}
+
++ (void)writeTK:(NSDictionary*)tk {
+    [[SCSettings sharedSettings] setValue: tk forKey: kBlockTimekeepingKey];
+}
+
++ (NSTimeInterval)inFlightDeltaFromTK:(NSDictionary*)tk
+                                  now:(NSDate*)now
+                       continuousNanos:(uint64_t)cont {
+    NSDate* lastWall  = tk[kLastCheckpointWallKey];
+    uint64_t lastCont = [tk[kLastCheckpointContKey] unsignedLongLongValue];
+
+    NSTimeInterval deltaWall = [now timeIntervalSinceDate: lastWall];
+    NSTimeInterval deltaCont = ((double)(cont - lastCont)) / 1e9;
+
+    NSTimeInterval trustedDelta = MIN(deltaCont, MAX(0.0, deltaWall));
+    if (trustedDelta < 0) trustedDelta = 0; // defense vs corrupt persisted lastCont
+    return trustedDelta;
+}
+
++ (void)tickCheckpoint {
+    NSDictionary* tk = [self readTK];
+    if (tk == nil) return;
+
+    NSDate* now = [NSDate date];
+    uint64_t cont = [self continuousNanos];
+    NSString* currentBoot = [self currentBootSessionUUID];
+
+    if (![tk[kBootSessionUUIDKey] isEqualToString: currentBoot]) {
+        // Cross-boot: monotonic counter has reset. Credit max(0, wall-clock gap).
+        NSTimeInterval gapWall = [now timeIntervalSinceDate: tk[kLastCheckpointWallKey]];
+        NSTimeInterval credit = MAX(0.0, gapWall);
+        NSTimeInterval newAccum = [tk[kElapsedAccumulatedKey] doubleValue] + credit;
+
+        NSMutableDictionary* updated = [tk mutableCopy];
+        updated[kElapsedAccumulatedKey] = @(newAccum);
+        updated[kLastCheckpointWallKey] = now;
+        updated[kLastCheckpointContKey] = @(cont);
+        updated[kBootSessionUUIDKey]    = currentBoot;
+        [self writeTK: updated];
+        return;
+    }
+
+    NSTimeInterval trustedDelta = [self inFlightDeltaFromTK: tk now: now continuousNanos: cont];
+    NSTimeInterval newAccum = [tk[kElapsedAccumulatedKey] doubleValue] + trustedDelta;
+
+    NSMutableDictionary* updated = [tk mutableCopy];
+    updated[kElapsedAccumulatedKey] = @(newAccum);
+    updated[kLastCheckpointWallKey] = now;
+    updated[kLastCheckpointContKey] = @(cont);
+    [self writeTK: updated];
+}
+
++ (NSTimeInterval)elapsedSecondsForCurrentBlock {
+    NSDictionary* tk = [self readTK];
+    if (tk == nil) return 0.0;
+    if (![tk[kBootSessionUUIDKey] isEqualToString: [self currentBootSessionUUID]]) {
+        return [tk[kElapsedAccumulatedKey] doubleValue];
+    }
+    return [tk[kElapsedAccumulatedKey] doubleValue]
+         + [self inFlightDeltaFromTK: tk now: [NSDate date] continuousNanos: [self continuousNanos]];
+}
+
++ (BOOL)blockDurationHasElapsed {
+    NSDictionary* tk = [self readTK];
+    if (tk == nil) return NO;
+    return [self elapsedSecondsForCurrentBlock] >= [tk[kBlockDurationSecondsKey] doubleValue];
+}
+
++ (NSTimeInterval)blockDurationSeconds {
+    NSDictionary* tk = [self readTK];
+    if (tk == nil) return 0.0;
+    return [tk[kBlockDurationSecondsKey] doubleValue];
+}
+
++ (NSTimeInterval)remainingSecondsForCurrentBlock {
+    NSDictionary* tk = [self readTK];
+    if (tk == nil) return 0.0;
+    NSTimeInterval duration = [tk[kBlockDurationSecondsKey] doubleValue];
+    NSTimeInterval elapsed  = [self elapsedSecondsForCurrentBlock];
+    NSTimeInterval remaining = duration - elapsed;
+    return remaining > 0 ? remaining : 0.0;
+}
+
+@end

Common/Utility/SCBlockUtilities.h

@@ -18,6 +18,10 @@ NS_ASSUME_NONNULL_BEGIN
 
 + (BOOL)currentBlockIsExpired;
 
+/// Strict check: both wall-clock and monotonic counter say the block is over.
+/// Use this in the daemon before tearing down firewall rules.
++ (BOOL)currentBlockIsTrulyExpired;
+
 + (BOOL)blockRulesFoundOnSystem;
 
 + (void)removeBlockFromSettings;

Common/Utility/SCBlockUtilities.m

@@ -8,6 +8,7 @@
 #import "SCBlockUtilities.h"
 #import "HostFileBlocker.h"
 #import "PacketFilter.h"
+#import "SCBlockClock.h"
 
 @implementation SCBlockUtilities
 
@@ -61,6 +62,11 @@ + (BOOL)currentBlockIsExpired {
     }
 }
 
++ (BOOL)currentBlockIsTrulyExpired {
+    if (![self currentBlockIsExpired]) return NO;
+    return [SCBlockClock blockDurationHasElapsed];
+}
+
 + (BOOL)blockRulesFoundOnSystem {
     return [PacketFilter blockFoundInPF] || [HostFileBlocker blockFoundInHostsFile];
 }

Common/Utility/SCPinnedHosts.h

@@ -0,0 +1,15 @@
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// Baked-in pin list for the trusted-time HTTPS gate. Each entry is
+/// @{ @"host": @"<hostname>", @"spki": @"<base64 SHA-256 of leaf SPKI>" }.
+/// The quorum check requires 2 of 3 to succeed, so a single rotation
+/// failure does not break the gate.
+@interface SCPinnedHosts : NSObject
+
++ (NSArray<NSDictionary<NSString*, NSString*>*>*)hosts;
+
+@end
+
+NS_ASSUME_NONNULL_END

Common/Utility/SCPinnedHosts.m

@@ -0,0 +1,22 @@
+#import "SCPinnedHosts.h"
+
+@implementation SCPinnedHosts
+
++ (NSArray<NSDictionary<NSString*, NSString*>*>*)hosts {
+    static NSArray* hosts = nil;
+    static dispatch_once_t once;
+    dispatch_once(&once, ^{
+        // Pins are SHA-256 (base64) of SecKeyCopyExternalRepresentation() output
+        // for the leaf certificate's public key — i.e., the raw public-key bytes
+        // (RSA modulus+exponent, or EC point), NOT the full ASN.1 SPKI.
+        // To recompute, see the SCTrustedTime pinning delegate in SCTrustedTime.m.
+        hosts = @[
+            @{ @"host": @"www.apple.com",      @"spki": @"vGYr5lNKlPJ0wSZMROTsiP+dd8iCbBOe7YZMVoy4cK0=" },
+            @{ @"host": @"www.google.com",     @"spki": @"u6g6X+7KXDBCQ91pQEWODwB8+hbZW43/7pbjYIAzpNU=" },
+            @{ @"host": @"www.cloudflare.com", @"spki": @"b1g23yk9nBZr6VXWRfLBYuSS/kzvrmf565y9Cs+3sNw=" },
+        ];
+    });
+    return hosts;
+}
+
+@end

Common/Utility/SCTrustedTime.h

@@ -0,0 +1,30 @@
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// Trusted-internet time verification for the block unlock gate.
+/// All callers must be prepared for any method to return nil/NO on failure.
+@interface SCTrustedTime : NSObject
+
+/// Parses an HTTP IMF-fixdate (RFC 7231 §7.1.1.1). Returns nil on any error.
++ (nullable NSDate*)parseHTTPDateHeader:(nullable NSString*)header;
+
+typedef void (^SCTrustedTimeCompletion)(NSDate* _Nullable verifiedTime, NSError* _Nullable error);
+
+/// Fetches https://<host>/ HEAD and returns the time from the Date: header IFF
+/// the server's leaf SubjectPublicKeyInfo SHA-256 (base64) matches expectedSPKI.
++ (void)fetchTimeFromHost:(NSString*)host
+             expectedSPKI:(NSString*)spki
+                  timeout:(NSTimeInterval)timeoutSeconds
+               completion:(SCTrustedTimeCompletion)completion;
+
+typedef void (^SCTrustedTimeQuorumCompletion)(BOOL verified, NSDate* _Nullable medianTime, NSError* _Nullable error);
+
+/// Returns verified=YES iff at least 2 pinned hosts respond, all returned times
+/// are within 5 minutes of each other, and the median response is >= threshold.
++ (void)verifyTimeIsAfter:(NSDate*)threshold
+               completion:(SCTrustedTimeQuorumCompletion)completion;
+
+@end
+
+NS_ASSUME_NONNULL_END