@npaw/forge-react-native 9.6.1

package/ios/ForgeApple/Sources/NPAWForgeNetworkCaptureObjC/NPAWForgeNetworkSwizzler.m

@@ -0,0 +1,293 @@
+/**
+ * Copyright (C) NPAW - All Rights Reserved
+ *
+ * This source code is protected under international copyright law. All rights
+ * reserved and protected by the copyright holders.
+ * This file is confidential and only available to authorized individuals with the
+ * permission of the copyright holders. If you encounter this file and do not have
+ * permission, please contact the copyright holders and delete this file.
+ *
+ *
+ * @author: Victor Soto <victor.soto@nicepeopleatwork.com>
+ * @description: Clean-room Objective-C swizzling implementation for NSURLSession and NSURLConnection capture.
+ */
+
+#import "NPAWForgeNetworkSwizzler.h"
+#import <objc/runtime.h>
+#import <os/lock.h>
+
+// Shared configuration written by +installWithCallback:blockedHosts: and read
+// from arbitrary URLSession/NSURLConnection completion threads. All access goes
+// through NPAWStateLock so a re-install never races ARC release of the previous
+// callback block or blocked-hosts set against an in-flight completion.
+static NPAWForgeNetworkTraceCallback NPAWNetworkCallback;
+static NSSet<NSString *> *NPAWBlockedHosts;
+static BOOL NPAWInstalled;
+static os_unfair_lock NPAWStateLock = OS_UNFAIR_LOCK_INIT;
+
+// Thread-local guard so a convenience dataTask variant that funnels into another
+// swizzled variant on the same thread wraps (and therefore emits) exactly once.
+static _Thread_local BOOL NPAWWrappingInProgress;
+
+static NPAWForgeNetworkTraceCallback NPAWCurrentCallback(void) {
+    os_unfair_lock_lock(&NPAWStateLock);
+    NPAWForgeNetworkTraceCallback callback = NPAWNetworkCallback;
+    os_unfair_lock_unlock(&NPAWStateLock);
+    return callback;
+}
+
+static NSSet<NSString *> *NPAWCurrentBlockedHosts(void) {
+    os_unfair_lock_lock(&NPAWStateLock);
+    NSSet<NSString *> *blockedHosts = NPAWBlockedHosts;
+    os_unfair_lock_unlock(&NPAWStateLock);
+    return blockedHosts;
+}
+
+static long long NPAWNowMs(void) {
+    return (long long)([[NSDate date] timeIntervalSince1970] * 1000.0);
+}
+
+static NSString *NPAWTrimmedURL(NSURL *url) {
+    if (url == nil) {
+        return @"unknown";
+    }
+    NSURLComponents *components = [NSURLComponents componentsWithURL:url resolvingAgainstBaseURL:NO];
+    components.user = nil;
+    components.password = nil;
+    components.query = nil;
+    components.fragment = nil;
+    return components.URL.absoluteString ?: url.absoluteString ?: @"unknown";
+}
+
+static BOOL NPAWShouldBlock(NSURLRequest *request) {
+    NSString *host = request.URL.host.lowercaseString;
+    if (host.length == 0) {
+        return NO;
+    }
+    return [NPAWCurrentBlockedHosts() containsObject:host];
+}
+
+static NSString *NPAWOutcome(NSHTTPURLResponse *response, NSError *error) {
+    if (error != nil) {
+        if (error.code == NSURLErrorCancelled) {
+            return @"cancelled";
+        }
+        if (error.code == NSURLErrorTimedOut) {
+            return @"timeout";
+        }
+        return @"network_error";
+    }
+    NSInteger status = response.statusCode;
+    if (status >= 200 && status < 400) {
+        return @"success";
+    }
+    if (status > 0) {
+        return @"http_error";
+    }
+    return @"unknown";
+}
+
+static void NPAWEmit(NSURLRequest *request, NSURLResponse *response, NSData *data, NSError *error, long long startMs, NSString *source) {
+    NPAWForgeNetworkTraceCallback callback = NPAWCurrentCallback();
+    if (callback == nil || NPAWShouldBlock(request)) {
+        return;
+    }
+    long long endMs = NPAWNowMs();
+    NSHTTPURLResponse *http = [response isKindOfClass:NSHTTPURLResponse.class] ? (NSHTTPURLResponse *)response : nil;
+    NSMutableDictionary<NSString *, NSString *> *payload = [NSMutableDictionary dictionary];
+    payload[@"eventId"] = NSUUID.UUID.UUIDString;
+    payload[@"source"] = source;
+    payload[@"targetUrl"] = NPAWTrimmedURL(request.URL);
+    payload[@"method"] = request.HTTPMethod ?: @"GET";
+    payload[@"timestampMs"] = @"0";
+    payload[@"durationMs"] = [NSString stringWithFormat:@"%lld", MAX(0, endMs - startMs)];
+    payload[@"responseStatusCode"] = [NSString stringWithFormat:@"%ld", (long)(http != nil ? http.statusCode : 0)];
+    payload[@"outcome"] = NPAWOutcome(http, error);
+    if (error.localizedDescription.length > 0) {
+        payload[@"errorMessage"] = error.localizedDescription;
+    }
+    // Body SIZES only, never body content: measured byte counts first, the
+    // Content-Length header as fallback (kernel size contract feeding the
+    // requestBytes/responseBytes wire keys and net.bytes_out/net.bytes_in).
+    if (data.length > 0) {
+        payload[@"responseBytes"] = [NSString stringWithFormat:@"%lu", (unsigned long)data.length];
+    } else if (response.expectedContentLength > 0) {
+        payload[@"responseBytes"] = [NSString stringWithFormat:@"%lld", response.expectedContentLength];
+    }
+    if (request.HTTPBody.length > 0) {
+        payload[@"requestBytes"] = [NSString stringWithFormat:@"%lu", (unsigned long)request.HTTPBody.length];
+    } else {
+        long long declaredRequestLength = [request valueForHTTPHeaderField:@"Content-Length"].longLongValue;
+        if (declaredRequestLength > 0) {
+            payload[@"requestBytes"] = [NSString stringWithFormat:@"%lld", declaredRequestLength];
+        }
+    }
+    if (http.MIMEType.length > 0) {
+        payload[@"responseHeader.Content-Type"] = http.MIMEType;
+    }
+    callback(payload);
+}
+
+static void NPAWSwizzleInstanceMethod(Class cls, SEL original, SEL replacement) {
+    Method originalMethod = class_getInstanceMethod(cls, original);
+    Method replacementMethod = class_getInstanceMethod(cls, replacement);
+    if (originalMethod == NULL || replacementMethod == NULL) {
+        return;
+    }
+    class_addMethod(
+        cls,
+        replacement,
+        method_getImplementation(replacementMethod),
+        method_getTypeEncoding(replacementMethod)
+    );
+    replacementMethod = class_getInstanceMethod(cls, replacement);
+    if (replacementMethod == NULL) {
+        return;
+    }
+    if (class_addMethod(
+            cls,
+            original,
+            method_getImplementation(replacementMethod),
+            method_getTypeEncoding(replacementMethod)
+        )) {
+        class_replaceMethod(
+            cls,
+            replacement,
+            method_getImplementation(originalMethod),
+            method_getTypeEncoding(originalMethod)
+        );
+        return;
+    }
+    method_exchangeImplementations(originalMethod, replacementMethod);
+}
+
+static void NPAWSwizzleClassMethod(Class cls, SEL original, SEL replacement) {
+    Class metaClass = object_getClass(cls);
+    Method originalMethod = class_getClassMethod(cls, original);
+    Method replacementMethod = class_getClassMethod(cls, replacement);
+    if (metaClass == Nil || originalMethod == NULL || replacementMethod == NULL) {
+        return;
+    }
+    method_exchangeImplementations(originalMethod, replacementMethod);
+}
+
+@interface NSURLSession (NPAWForgeNetworkCapture)
+- (NSURLSessionDataTask *)npaw_dataTaskWithRequest:(NSURLRequest *)request completionHandler:(void (^)(NSData *_Nullable data, NSURLResponse *_Nullable response, NSError *_Nullable error))completionHandler;
+- (NSURLSessionDataTask *)npaw_dataTaskWithURL:(NSURL *)url completionHandler:(void (^)(NSData *_Nullable data, NSURLResponse *_Nullable response, NSError *_Nullable error))completionHandler;
+@end
+
+@implementation NSURLSession (NPAWForgeNetworkCapture)
+
+- (NSURLSessionDataTask *)npaw_dataTaskWithRequest:(NSURLRequest *)request completionHandler:(void (^)(NSData *_Nullable data, NSURLResponse *_Nullable response, NSError *_Nullable error))completionHandler {
+    if (NPAWWrappingInProgress) {
+        // Funneled here from another swizzled convenience variant on this thread:
+        // that variant already wrapped the completion, so pass through untouched
+        // to guarantee a single emission per request.
+        return [self npaw_dataTaskWithRequest:request completionHandler:completionHandler];
+    }
+    long long startMs = NPAWNowMs();
+    void (^wrapped)(NSData *_Nullable, NSURLResponse *_Nullable, NSError *_Nullable) = ^(NSData *_Nullable data, NSURLResponse *_Nullable response, NSError *_Nullable error) {
+        NPAWEmit(request, response, data, error, startMs, @"automatic_urlsession");
+        if (completionHandler != nil) {
+            completionHandler(data, response, error);
+        }
+    };
+    NPAWWrappingInProgress = YES;
+    NSURLSessionDataTask *task = [self npaw_dataTaskWithRequest:request completionHandler:wrapped];
+    NPAWWrappingInProgress = NO;
+    return task;
+}
+
+- (NSURLSessionDataTask *)npaw_dataTaskWithURL:(NSURL *)url completionHandler:(void (^)(NSData *_Nullable data, NSURLResponse *_Nullable response, NSError *_Nullable error))completionHandler {
+    if (NPAWWrappingInProgress) {
+        return [self npaw_dataTaskWithURL:url completionHandler:completionHandler];
+    }
+    NSURLRequest *request = [NSURLRequest requestWithURL:url];
+    long long startMs = NPAWNowMs();
+    void (^wrapped)(NSData *_Nullable, NSURLResponse *_Nullable, NSError *_Nullable) = ^(NSData *_Nullable data, NSURLResponse *_Nullable response, NSError *_Nullable error) {
+        NPAWEmit(request, response, data, error, startMs, @"automatic_urlsession");
+        if (completionHandler != nil) {
+            completionHandler(data, response, error);
+        }
+    };
+    NPAWWrappingInProgress = YES;
+    NSURLSessionDataTask *task = [self npaw_dataTaskWithURL:url completionHandler:wrapped];
+    NPAWWrappingInProgress = NO;
+    return task;
+}
+
+@end
+
+@interface NSURLConnection (NPAWForgeNetworkCapture)
++ (void)npaw_sendAsynchronousRequest:(NSURLRequest *)request queue:(NSOperationQueue *)queue completionHandler:(void (^)(NSURLResponse *_Nullable response, NSData *_Nullable data, NSError *_Nullable connectionError))handler;
+@end
+
+@implementation NSURLConnection (NPAWForgeNetworkCapture)
+
++ (void)npaw_sendAsynchronousRequest:(NSURLRequest *)request queue:(NSOperationQueue *)queue completionHandler:(void (^)(NSURLResponse *_Nullable response, NSData *_Nullable data, NSError *_Nullable connectionError))handler {
+    long long startMs = NPAWNowMs();
+    [self npaw_sendAsynchronousRequest:request queue:queue completionHandler:^(NSURLResponse *_Nullable response, NSData *_Nullable data, NSError *_Nullable connectionError) {
+        NPAWEmit(request, response, data, connectionError, startMs, @"automatic_nsurlconnection");
+        if (handler != nil) {
+            handler(response, data, connectionError);
+        }
+    }];
+}
+
+@end
+
+@implementation NPAWForgeNetworkSwizzler
+
++ (BOOL)installWithCallback:(NPAWForgeNetworkTraceCallback)callback
+              blockedHosts:(NSSet<NSString *> *)blockedHosts {
+    @synchronized (self) {
+        os_unfair_lock_lock(&NPAWStateLock);
+        NPAWNetworkCallback = [callback copy];
+        NPAWBlockedHosts = [blockedHosts copy] ?: [NSSet set];
+        os_unfair_lock_unlock(&NPAWStateLock);
+        if (NPAWInstalled) {
+            return YES;
+        }
+        Class sharedSessionClass = object_getClass(NSURLSession.sharedSession);
+        Class sessionClasses[] = { sharedSessionClass, NSURLSession.class };
+        for (NSUInteger index = 0; index < 2; index++) {
+            Class cls = sessionClasses[index];
+            if (cls == Nil || (index == 1 && cls == sharedSessionClass)) {
+                continue;
+            }
+            NPAWSwizzleInstanceMethod(
+                cls,
+                @selector(dataTaskWithRequest:completionHandler:),
+                @selector(npaw_dataTaskWithRequest:completionHandler:)
+            );
+            NPAWSwizzleInstanceMethod(
+                cls,
+                @selector(dataTaskWithURL:completionHandler:),
+                @selector(npaw_dataTaskWithURL:completionHandler:)
+            );
+        }
+        NPAWSwizzleClassMethod(
+            NSURLConnection.class,
+            @selector(sendAsynchronousRequest:queue:completionHandler:),
+            @selector(npaw_sendAsynchronousRequest:queue:completionHandler:)
+        );
+        NPAWInstalled = YES;
+        return YES;
+    }
+}
+
++ (void)uninstall {
+    @synchronized (self) {
+        os_unfair_lock_lock(&NPAWStateLock);
+        NPAWNetworkCallback = nil;
+        NPAWBlockedHosts = nil;
+        os_unfair_lock_unlock(&NPAWStateLock);
+        // NPAWInstalled deliberately stays YES and the exchanged IMPs stay in
+        // place: re-exchanging implementations is unsafe when another library
+        // swizzled the same selectors after us (we would splice their IMP out
+        // of the chain, not restore the original). With the callback cleared,
+        // NPAWEmit no-ops until the next install re-sets the state.
+    }
+}
+
+@end

package/ios/ForgeApple/Sources/NPAWForgeNetworkCaptureObjC/include/NPAWForgeNetworkSwizzler.h

@@ -0,0 +1,33 @@
+/**
+ * Copyright (C) NPAW - All Rights Reserved
+ *
+ * This source code is protected under international copyright law. All rights
+ * reserved and protected by the copyright holders.
+ * This file is confidential and only available to authorized individuals with the
+ * permission of the copyright holders. If you encounter this file and do not have
+ * permission, please contact the copyright holders and delete this file.
+ *
+ *
+ * @author: Victor Soto <victor.soto@nicepeopleatwork.com>
+ * @description: Objective-C runtime swizzler entrypoint for Apple network capture.
+ */
+
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+typedef void (^NPAWForgeNetworkTraceCallback)(NSDictionary<NSString *, NSString *> *payload);
+
+@interface NPAWForgeNetworkSwizzler : NSObject
+
++ (BOOL)installWithCallback:(NPAWForgeNetworkTraceCallback)callback
+              blockedHosts:(NSSet<NSString *> *)blockedHosts;
+
+// Clears the stored callback and blocked-hosts state so no further payloads are
+// emitted. The swizzled implementations stay installed for the process lifetime;
+// a later install resumes capture by re-setting the callback.
++ (void)uninstall;
+
+@end
+
+NS_ASSUME_NONNULL_END