A little and powerful iOS framework for intercepting HTTP/HTTPS Traffic.

My Mac and iPhone are connected to the same network and are connected by a USB cable. However, when launching an app with Atlantis inside, it is unable to find Proxyman in the network, even if I specify hostname. It connects successfully only if I:

1. Launch the app for the first time. Atlantis successfully connects upon giving local network permission.
2. I put the app to background for a second or longer. Atlantis successfully connects upon reopening the app.

The issue was not present about 2 months ago, when I last used this awesome tool!

I successfully build with 1.18.1 but 1.18.2 can't build with carthage

Console: xcodebuild timed out while trying to read Atlantis-Example-App.xcodeproj 😭

carthage 0.38.0 (installed with brew to m1 mac) macOS 12.4 Xcode 13.4.1 Xcode build version: Xcode 13.4.1 Build version 13F100 Command: carthage update --use-xcframeworks --cache-builds

With Atlantis 1.16.0 and Xcode 13.3.1, running Atlantis.start() sometimes produces a EXC_BAD_ACCESS error (in NetworkInjector:injectAllURLConnection() function). The error does not occur with Xcode 13.3.0.

I get this assertion failure when using file URLs.

Fatal error: Only support HTTPURLResponse: file Atlantis/Packages.swift, line 209

It can be reproduced with this code in an iOS app.

if let url = Bundle.main.url(forResource: "Info", withExtension: "plist") {
  let task = URLSession.shared.downloadTask(with: url)
  task.resume()
}

In our app, many resources are retrieved from a web server, while some are bundled in the app. For a specific kind of resource, we want to use the same implementation for web and bundled file, which uses URLSessionDownloadTask. It would be helpful if this assertionFailure is removed.

I'm trying to import Atlantis into my project but getting the error:

Could not find module 'Atlantis' for target 'x86_64-apple-ios-simulator'; found: arm64-apple-ios-simulator, at: /Users/.../Index.noindex/Build/Products/Debug-iphonesimulator/Atlantis.swiftmodule

I am integrating this using SPM in a project that also contains Cocoapods.

• M1 Pro
• Atlantis 1.18.2
• Xcode Version 14.1 (14B47b)
• Building for simulator iPhone 14 Pro 16.0

Version: 1.2.0 (d918263) integrated using SPM. Device: Simulator running iOS 13.0.

This happens in NetworkInjector+URLSession.swift:82, due to a failed safe-check in this line:

if let task = me.value(forKey: "task") as? URLSessionDataTask

The response URL is starting with https://app-measurement.com/config/app/.... So most likely, this is a request sent by Firebase SDK (namely Firebase Remote Config feature).

Some LLDB info:

po me.value(forKey: "task") as? URLSessionDataTask

nil

po type(of: me.value(forKey: "task")!)

__NSCFLocalDownloadTask

po dump(me.value(forKey: "task")!)

- LocalDownloadTask <20850171-C07B-4A76-9195-08F62CCB7ACC>.<1> #0
  - super: __NSCFLocalSessionTask
    - super: __NSCFURLSessionTask
      - super: NSURLSessionTask
        - super: NSObject
LocalDownloadTask <20850171-C07B-4A76-9195-08F62CCB7ACC>.<1>

Any) $R96 = {
  payload_data_0 = 0x00007fe1e4601ce0 {
    base__NSCFLocalSessionTask@0 = {
      base__NSCFURLSessionTask@0 = {
        baseNSURLSessionTask@0 = {
          baseNSObject@0 = {
            isa = __NSCFLocalDownloadTask
          }
          _nw_activity_ivar = nil
          _metrics_ivar = 0x000060000191c360
          earliestBeginDate = nil
          _private_nw_activity = nil
          __taskGroup = 0x00007fe1e4503dc0
        }
        _cachedSocketStreamProperties = 0x0000600003d52780
        _httpConnectionInfoCompletionBlock = nil
        _taskIdentifier = 1
        _taskDescription = nil
        _loggableDescription = 0x0000600001ea0af0 "Task <20850171-C07B-4A76-9195-08F62CCB7ACC>.<1>"
        _originalRequest = some {
          some = 0x0000600003f09930 {
            baseNSURLRequest@0 = {
              baseNSObject@0 = {
                isa = NSMutableURLRequest
              }
              _internal = 0x0000600000606f20
            }
          }
        }
        _currentRequest = some {
          some = 0x0000600003f31850 {
            baseNSURLRequest@0 = {
              baseNSObject@0 = {
                isa = NSMutableURLRequest
              }
              _internal = 0x000060000060e2f0
            }
          }
        }
        _response = some {
          some = 0x0000600003c205c0 {
            baseNSURLResponse@0 = {
              baseNSObject@0 = {
                isa = NSHTTPURLResponse
              }
              _internal = 0x0000600001640460
            }
            _httpInternal = 0x0000600003c20200
          }
        }
        _countOfBytesClientExpectsToSend = -1
        _countOfBytesClientExpectsToReceive = -1
        _countOfBytesReceived = 0
        __countOfPendingBytesReceivedEncoded = 0
        __countOfBytesReceivedEncoded = 0
        _countOfBytesSent = 0
        _countOfBytesExpectedToSend = 0
        _countOfBytesExpectedToReceive = -1
        _state = 0
        _error = nil
        _startTime = 626263406.09285104
        __TCPConnectionMetadata = nil
        _TLSNegotiatedCipherSuite = 4865
        _priorityHint = 0.5
        _priorityValue = 300
        _loadingPriorityValue = 0.5
        _bytesPerSecondLimitValue = 0
        _expectedProgressTargetValue = 0
        _backgroundTransactionMetrics = nil
        _legacySocketStreamProperties = nil
        _cfHSTS = 0x0000000000000000
        _cfCache = 0x0000000000000000
        _cfCreds = 0x0000000000000000
        _cfCookies = 0x0000000000000000
        _cachePolicy = 1
        _timeoutInterval = 60
        _timeoutIntervalForResource_ivar = 60
        _proxySettings = nil
        _sslSettings = 0x0000600003d51ea0
        _cookieAcceptPolicy = 2
        _contentDispositionFallbackArray = nil
        _networkServiceType = 0
        _qos = 9
        _voucher = nil
        _suspensionThreshhold = 524288
        _boundInterfaceIdentifier = nil
        _allowedProtocolTypes = 0
        _requestPriority = -1
        _expectedWorkload = 0
        _timeWindowDelay = 0
        _timeWindowDuration = 0
        _uniqueIdentifier = 0x0000600003c364e0
        _powerAssertion = 0
        _darkWakePowerAssertion = 0
        _effectiveConfiguration = 0x0000600003f096c0
        _protocolForTask = nil
        _authenticator = nil
        _storagePartitionIdentifier = nil
        _parentDocumentURL = nil
        _siteForCookies = nil
        _dependencyInfo_ivar = 0x0000600003c3acc0 1 key/value pair
        _DuetActivityProperties = nil
        _dependencyTree = nil
        _taskDependency = nil
        _pathToDownloadTaskFile = nil
        _trailers = nil
        _discretionaryOverride = 0
        _appleIDContext = nil
        _progress = nil
        _uploadProgress = nil
        _downloadProgress = nil
        _publishingURL = nil
        _backgroundPublishingURL = nil
        _APSRelayTopic = nil
        _extractor = nil
        _extractorFinishedDecoding = false
        _hasSZExtractor = false
        _doesSZExtractorConsumeExtractedData = false
        _shouldSkipPreferredClientCertificateLookup = false
        _cacheOnly = false
        _preventsSystemHTTPProxyAuthentication = false
        _requiresSecureHTTPSProxyConnection = false
        _preventsAppSSO = false
        _appSSOFallback = false
        _shouldPipelineHTTP = false
        _shouldUsePipelineHeuristics = false
        _shouldSkipPipelineProbe = false
        _shouldHandleCookies = true
        _isTopLevelNavigation = false
        _prohibitAuthUI = false
        _strictContentLength = true
        _connectionIsCellular = false
        _disallowCellular = false
        _allowsCellular = true
        _allowsExpensiveOverride = 0
        _allowsConstrainedOverride = 0
        _allowsCellularOverride = 0
        _isInUpload = false
        _undeterminedUploadProgressState = false
        _undeterminedDownloadProgressState = false
        _progressReportingFinished = false
        _allowsQUIC = false
        _preventsIdleSystemSleep = false
        _preconnect = false
        _authenticatorConfiguredViaTaskProperty = false
        _seenFirstResume = true
        _atsStateCache = 0x00006000023a5700
        _connectionIsCompanionLink = false
        _extractorPreparedForExtraction = false
      }
      _cfConn = 0x000060000086f840
      _uploadFile = nil
      _dataTaskData = nil
      _dataTaskCompletion = nil
      _pendingResponseBytes = nil
      _suspendCount = 0
      _async_initialization = nil
      _resourceTimeout = some {
        some = 0x0000600001318a80 {
          baseOS_dispatch_object@0 = {
            baseOS_object@0 = {
              baseNSObject@0 = {
                isa = OS_dispatch_source
              }
            }
          }
        }
      }
      _startTimeoutTime = 0
      _startTimeoutTimer = nil
      _payloadTransmissionTimer = nil
      _willSendRequestTimer = nil
      _socketReadStreamForUpgrade = nil
      _socketWriteStreamForUpgrade = nil
      _extraBytes = nil
      _connectionWorkQueue = nil
      _connectionWorkQueueSuspensionCount = 0
      _pendingResponseDisposition = false
      _pendingResponseDisposition_didFinish = false
      _didIssueWaitingForConnectivity = false
      _didIssueDidFinish = false
      _suspendedForDisposition = false
      _didCheckMixedReplace = true
      _isMixedReplace = false
    }
    _fileCompletion = nil
    _downloadFile = 0x000060000060e080
    _writeBuffer = nil
    _ioSuspend = 0
    _totalWrote = 0
    _resumeCallback = nil
    _initialResumeSize = -1
    _originalResumeInfo = nil
    _transientWriteProgress = 0
    _afterDidReportProgressOnQueue = nil
    _dataAckCompletion = nil
    _seqNo = 0
    _canWrite = true
    _suppressProgress = false
    _needFinish = false
    _didIssueNeedFinish = false
  }
  payload_data_1 = 0x000000010e8e5a00
  payload_data_2 = 0x00007fe1e4879628
  instance_type = 0x00007fe1e4879628

I'm trying to replace the proxy setup with Atlantis but it's not capturing most of the request bodies. Doing the same request over and over again, it was only the request body for a couple of them.

Using the latest version via SPM. Running on a physical device with iOS 14.2.1.

Thanks for developing atlantis, however our project's deployment version is still iOS 11. Is it possible to allow installing atlantis on < iOS 12? Without functioning on older version is okay but only allow it to install (Maybe adding some #available flags?) on projects that deployment version are still on older versions

We have Atlantis in our app, and the app receives a lot of web socket messages. If Proxyman isn't running, all these messages (and any other network requests) get appended to pendingPackages here: https://github.com/ProxymanApp/atlantis/blob/main/Sources/Transporter.swift#L95

There seems to be no limit on the size of this array, so this will continue until the app runs out of memory, or Proxyman is launched.

It would be great to have an option to disable the storing of pending packages, so if you don't have Proxyman running, these packages are just lost, and you only start seeing new data in Proxyman from the moment you start it.

Hi, I saw that the 1.8.0 release was pushed yesterday. Is it possible to ensure that release notes are added to those releases? Given the nature of what Atlantis does its helpful to be able to distribute that as a link to our team.

https://github.com/ProxymanApp/atlantis/releases/tag/1.8.0

Hi!

I’m using Atlantis and everything seems to setup correctly, I can see all the traffic from the device etc, but when I try to map a response nothing happens. In this example a replaced the status code but when I re run the app nothing gets mapped. Same map local works as expected in the simulator.

Hello,

I'm using SocketRocket library on my iOS client app. I've also installed Atlantis.

This way, on desktop Proxyman I can see all HTTPS requests made from my iOS app. However, I don't see any WebSocket requests, the tab is just empty in Proxyman.

I tried using URLSessionWebSocketTask and the WebSocket requests are correctly displayed in Proxyman.

Could you suggest what might be an issue with SocketRocket and how to fix it?

Description

If we use Atlantis on an iOS 16 Physical device, most of the time the Atlantis service cannot successfully connect to Proxyman macOS app.

Always get the following error:

[Atlantis] ❌ Connection to Proxyman app is failed, error=POSIXErrorCode(rawValue: 54): Connection reset by peer

Reason: We suspect that NSNetServiceBrowser is deprecated, so it might not work on iOS 16. NSNetServiceBrowser is a legacy framework for Bonjour Connection.

To workaround, use the iOS 16 Simulator.

Steps to Reproduce

1. Use iOS 16 physical device and integrate Atlantis framework
2. Start the app

Current Behavior

3. Observe that the connection is failed ❌

Expected Behavior

• The connection should work

Environment

• App version: Proxyman 3.13.0 + Atlantis 1.19.0
• macOS version: macOS Monterey

hi, me and my colleagues are experiencing duplicated connections from atlantis to Proxyman when we are working at the office. Thus, we receive the same network request multiple times with the exact same time, duration etc.

I couldn't find the root of the issue, but filtering in NetServiceTransport#connectToService(_ service: NetService) also gets the job done. Maybe it could be a change to be considered for a future release. Let's see if I manage to create a PR

A problem could be that with that change devices which have the same name couldn't connect both over the network to atlantis

The Atlantis library has been really useful because I couldn't get a working setup with just the Proxyman macOS app due to VPN issues (though have just managed to hopefully finally resolve that by using the allow-list!) and Alantis actually managed to get network logs working!

But there were some quirks regarding how Atlantis intercepts the network traffic and my app's own networking complexities conflicted (both use URLProtocol). It basically meant that the network logs weren't showing an accurate or stable picture of what was conceptually happening.

Largely this was down to my networking code intercepting looking for specific error responses to requests within my URLProtocol and then replaying the request differently to get a successful response (relating to handling custom authentication challenges).

I've put together a simple sample app that illustrates the difference between using Atlantis and not in this sort of scenario: AtlantisTest.zip

The sample app sends a request that gets a 404 response, catches that in my URLProtocol and then makes another request that gets a 200 and reports that result to the request that made the 404 request. So the original request doesn't know about the replay, but gets the result that it really wanted (it's a simplified example so might not make a huge amount of sense!)

Without Atlantis without atlantis.proxymanlog.zip Just see the two requests, with IDs ordered the same as their timestamps, which is what I'd hope for as this is the reality

With Atlantis with atlantis.proxymanlog.zip See four requests, with IDs that don't match the order of the timestamps. This obviously makes it hard to look at exported network logs and make sense of what was really going on.

Not sure if there's a huge amount that can be done about this though! Even if I register my URLProtocol before or after starting Atlantis the result is the same.

title says it all; there's no reason you have to make it work, but you're going to have to sooner than later. We compile with 'warnings as errors' on - not sure if this was just warnings or errors, but bottom line, it breaks our build.