In [Part 1](/articles/read-and-write-files-in-user-folders) we saw how to use the sandbox and how to ask the user permission to read from and write to folders outside the app container.
In this article we will see how to persist the user's permissions across app launches.
Since, once the user kills the app, these permissions are erased.
So, without further ado, let's begin!
##  Steps
Let's summarise the main step of the process.
1. [Ask the user](/articles/read-and-write-files-in-user-folders) which folder he wants to save the file in
2. Create and persist bookmark data for the folder URL the user selected
3. Make the resource referenced by the url accessible to the process
4. Perform read/write operations
5. Revoke the access granted to the url
## Create and persist bookmark
As we saw in [Part 1](/articles/read-and-write-files-in-user-folders), once the user have selected the folder we create and persists its bookmark data in `UserDefaults`.
```swift
func persistBookmark(url: URL) throws -> Data {
   let bookmarkData = try url.bookmarkData(options: .withSecurityScope, includingResourceValuesForKeys: nil, relativeTo: nil)
   UserDefaults.standard.set(bookmarkData, forKey: key(for: url))
   return bookmarkData
}
 
// Helper function that creates the bookmark key
func key(for url: URL) -> String {
   String(format: "bd_%@", url.absoluteString)
}
```
The `withSecurityScope` key specifies that you want to create a security-scoped bookmark that, when resolved, provides a security-scoped URL allowing read/write access to a file-system resource.
## Access URL resources
Now, we can make the resource referenced by the url accessible to the process.
First we create a `struct` that holds our `URL`, `bookmarkData` and `permissions`.
```swift
struct AccessInfo {
 
  public var resolvedUrl: URL?
  public var bookmarkData: Data?
  public var permissions: Permissions
 
  static let empty = AccessInfo(permissions: .none)
}
```
Let's start we retrieving fresh bookmark data.
```swift
func bookmarkData(for url: URL) -> Data? {
    var folderUrl = url
 
    while !folderUrl.path.isEmpty {
      if let bookmark = UserDefaults.standard.data(forKey: key(for: folderUrl)) {
        return bookmark
      }
 
      folderUrl = folderUrl.deletingLastPathComponent()
    }
 
    return nil
}
 
func bookmarkInfo(for url: URL) -> AccessInfo {
    // 1.
    guard let oldBookmarkData = bookmarkData(for: url) else {
       return .empty
    }
 
    do {
      var bookmarkIsStale: Bool = false
 
      // 2.
      let resolvedUrl = try URL(resolvingBookmarkData: oldBookmarkData,
                               options: [.withSecurityScope, .withoutUI],
                               relativeTo: nil,
                               bookmarkDataIsStale: &bookmarkIsStale)
 
      // 3.
      if bookmarkIsStale {
        clearBookmarkData(for: url)
        let newBookmarkData = try persistBookmark(url: resolvedUrl)
 
        // 4.
        return AccessInfo(resolvedUrl: resolvedUrl, bookmarkData: newBookmarkData, permissions: .none)
      } else {
        // 4.
        return AccessInfo(resolvedUrl: resolvedUrl, bookmarkData: oldBookmarkData, permissions: .none)
      }
    } catch {
      print("Unable to resolve the bookmark data into a URL.")
      return .empty
    }
}
```
In `bookmarkData(for:)` we retrieve bookmark data for the folder the user have selected or for a parent folder, since if the user granted us permission to access the parent folder, we have the implicit permission to access each child folder.
Then in `bookmarkInfo(for:)` we:
1. Get the bookmark data for the url or parent path if we have it
2. Resolve the bookmark data into a URL object that will allow us to use the file
3. If the bookmark data is stale we'll attempt to recreate it with the existing url
4. Return the **resolved url** and the **old** or **fresh** bookmark data
## Check permissions
Then we check which permission we have on that specific `URL`.
First, let's create the `OptionSet` that will define the `Permissions` we can have.
```swift
struct Permissions: OptionSet {
 
  let rawValue: Int
 
  static let bookmark = Permissions(rawValue: 1 << 0)
  static let darwinReadOnly = Permissions(rawValue: 1 << 1)
  static let darwinboxReadWrite = Permissions(rawValue: 1 << 2)
 
  static let none: Permissions = []
  static let readOnly: Permissions = [.bookmark, .darwinboxReadOnly]
  static let readWrite: Permissions = [.bookmark, .darwinboxReadWrite]
 
  var canRead: Bool {
    self.contains(.bookmark) || self.contains(.darwinboxReadOnly)
  }
 
  var canWrite: Bool {
    self.contains(.bookmark) || self.contains(.darwinboxReadWrite)
  }
 
  init(rawValue newRawValue: Int) {
    rawValue = newRawValue
  }
 
  func matches(permissions: Permissions) -> Bool {
    if permissions == .none {
      return true
    }
 
    return !self.intersection(permissions).isEmpty
  }
}
```
And then the modes we will use to check for low level permissions.
```swift
enum DarwinAccess {
 
  enum AccessMode {
 
    case readOnly
    case readWrite
 
    var permission: Int32 {
      switch self {
      case .readOnly: return R_OK
      case .readWrite: return (R_OK | W_OK)
      }
    }
  }
 
  static func canAccess(url: URL, mode: AccessMode) -> Bool {
    let path = url.path as NSString
    return Darwin.access(path.fileSystemRepresentation, mode.permission) == 0
  }
}
```
Then we get the `bookmarkInfo(for:)` and check the `Permissions`.
```swift
func accessInfo(for url: URL) -> AccessInfo {
    // 1.
    let standardizedFileURL = url.standardizedFileURL.resolvingSymlinksInPath()
 
    // 2.
    var accessInfo = bookmarkInfo(for: standardizedFileURL)
 
    // 3.
    if accessInfo.resolvedUrl != nil {
      accessInfo.permissions.insert(.bookmark)
    }
 
    // 4.
    if DarwinAccess.canAccess(url: url, mode: .readOnly) {
      accessInfo.permissions.insert(.darwinReadOnly)
    }
 
    if DarwinAccess.canAccess(url: url, mode: .readWrite) {
      accessInfo.permissions.insert(.darwinboxReadWrite)
    }
 
    return accessInfo
}
```
In the function above we:
1. Standardize the file url and remove any symlinks
2. If url bookmark data are stored, then we'll get the `resolvedUrl` and its associated `bookmarkData`
3. If the `resolvedUrl` is not `nil`, it means that we successfully resolved the `bookmarkData` and we got back the `URL` with read/write permissions
4. Check if the OS let us read/write, this properties we will come into play only if `resolvedUrl` is nil
## Access the url
Finally, we can put all together and check if the user granted us the permissions we need.
```swift
func access(url: URL, permissions: Permissions, performManipulation: (URL) throws -> Void) throws {
    // 1.
    let accessInfo = accessInfo(for: url)
 
    // 2.
    if accessInfo.permissions.matches(permissions: permissions) {
      // 3.
      try secureAccess(resolvedURL: accessInfo.resolvedURL, fallbackUrl: url, performManipulation: performManipulation)
    } else {
      // 4.
      throw PermissionError.needToAskPermission(accessInfo)
    }
}
```
1. We get the `AccessInfo` for the requested `URL`
2. Then, we check if the permission the user granted us matches the permissions we need
3. If the permissions matches, we can access the `URL`
4. Else we throw an error
```swift
func secureAccess(resolvedURL: URL?, fallbackUrl: URL, performManipulation: (URL) throws -> Void) throws {
    guard let resolvedURL = url else {
      // 1.
      try performManipulation(fallbackUrl)
      return
    }
 
    // 2.
    if resolvedURL.startAccessingSecurityScopedResource() {
      // 3.
      try performManipulation(fallbackUrl)
      resolvedURL.stopAccessingSecurityScopedResource()
    } else {
 
      // 4.
      throw PermissionError.unexpectedlyUnableToAccessBookmark(resolvedURL)
    }
}
```
1. We don't have the resolvedURL but we do meet the permission so we can perform the URL manipulation without accessing the security scoped resource.
2. We access the security scoped resource and perform read/write operation on the `URL`
3. Here we pass the `fallbackUrl` that is the original url the user has selected. This is done because the `resolvedUrl` can be a parent of the selected url
4. Throw an error in case we are not able to access the security scoped resource of the `URL`
## Usage
```swift
do {
   let selectedFolder = openPanel()
 
   try persistBookmark(url: selectedFolder)
 
   try access(url: selectedFolder, permissions: .readWrite) { url in
      data.write(to: url)
   }
} catch {
   print(error)
}
```
## Conclusion
This is all I understood about read/write operations with **Sandboxed** apps.
The **App Sandbox** is a really important feature provided by Apple to keep the users' data safe and many developers don't know it's there until they need to write outside the app container.
So, I hope this guides helped you better understand what it is and how to use it.
If you already know this topic and have improvements to give about the article, I will be very thankful to add your suggestions.

Discover how to persist user's Mac folders and files permissions across app launches in an app with Sandbox enabled in Xcode.

Persist Access to User Folders Across Launches (Part 2)

If you are developing a Mac app you may need to read and write files to the user's Mac folders, outside of the app container.
I found myself in the same situation many times. So in this guide I want to share what is my understanding of this topic so far.
I gathered this information across forums, tutorials and the Apple documentation.
This is a vast topic that involves also user privacy and security of its data, in this guide we will cover only the actual implementation of the reading and writing process.
## App Sandbox
What is the **App Sandbox**?
[Apple's Documentation](https://developer.apple.com/documentation/security/app_sandbox) states that:
> (App Sandbox is used to) Restrict access to system resources and user data in macOS apps to contain damage if an app becomes compromised. App Sandbox provides protection to system resources and user data by limiting your app's access to resources requested through entitlements.
The app sandbox is meant to keep users safe from apps that contain malicious code or contain vulnerabilities that an attacker can exploit for malicious purposes. The sandbox protects users' assets from damage or theft.
Apple now mandates app sandboxing in iOS and macOS apps.
> To distribute a macOS app through the Mac App Store, you must enable the App Sandbox capability.
So, **the App Sandbox is like a wall that surrounds our app and lets us communicate only with the external resources that the user grant us permission**.
## Setup App Sandbox
To configure the App Sandbox, go to your **Target** and under **Signin & Capabilities** you should already see **App Sandbox**.
If that's not the case, hit the + button and search and add **App Sandbox**.
You should also see the **Hardened Runtime**, basically this is another security capability that protects the integrity of the software.
[Apple's Documentation](https://developer.apple.com/documentation/security/hardened_runtime) states that:
> The Hardened Runtime, along with System Integrity Protection (SIP), protects the runtime integrity of your software by preventing certain classes of exploits, like code injection, dynamically linked library (DLL) hijacking, and process memory space tampering.
Now, back to our App Sandbox.
Under **App Sandbox** you can see a lot of options, in this guide we will look at the **File Access** section.
These options controls, at a high level, which folders your app **can ask permission** to read, write or both.
This doesn't mean that by selecting **read/write** for **User Selected File** in the App Sandbox settings, you can access those folders right away. But you **still need to ask the user to give you permission** to read/write to those folder.
## Sandboxed vs. Un-sandboxed app
Say we need to create a file in the user's **Desktop**.
In an **un-sandboxed** app you can simply call `write(to:)`
```swift
try data.write(to: fileURL)
```
And you're done.
In a **sandboxed** app, instead, if we do the same process, the function returns an error that looks like this:
```terminal
You don't have permission to write to user folder.
```
This happens because in a sandboxed app you can only write to and read from the folders in the app’s container.
This is one of Apple's methods for limiting the vulnerable surface area of the app to attack by malware.
## Write to a sandboxed app
Now that we saw what is the behaviour of **sandboxed** and **un-sandboxed** app, let's see how to actually write from a **sandboxed** app.
Since we want to write to a non-default folder (like `Downloads`, `Images`, ...), we need to ask the user where to save our file.
So, in `TARGETS -> [TARGET_NAME] -> Signing & Capabilities -> App Sandbox -> File Access -> Type -> User Selected File` change `Permission & Access` from `None` to `Read/Write`.
This will add the `com.apple.security.files.user-selected.read-write` entitlement to your project.
### Ask where to save the file
Now, before to write the file, we must ask the user where he wants to save the file. We will do this using the `NSOpenPanel` class.
```swift
let openPanel = NSOpenPanel()
openPanel.prompt = "Select"
openPanel.message = "Please select a folder"
openPanel.allowedContentTypes = [.directory]
openPanel.canChooseFiles = false
openPanel.allowsOtherFileTypes = false
openPanel.allowsMultipleSelection = false
openPanel.canChooseDirectories = true
 
// Open the modal folder selection panel.
let okButtonPressed = openPanel.runModal()
 
if okButtonPressed == .OK {
   // If the user doesn't select anything, then the URL \"file:///\" is returned, which we ignore
   if let url = openPanel.urls.first,
      url.absoluteString != "file:///" {
     print("User selected folder: \\(url)")
     // Persist user selected folder for later launches
   } else {
     print("User did not select a folder")
   }
} else {
  print("User cancelled folder selection panel")
}
```
!NOTE This is a synchronous process even if there is user interaction. So you don't need completion blocks to perform actions when the user selects the folder.
Now, once the user selected the folder, you can write like we did in the **un-sandboxed** app.
```swift
let fileURL = URL(fileURLWithPath: "file_name.json", relativeTo: selectedFolderURL)
try data.write(to: fileURL)
```
## Persist user intent across launches
See how to persist the selected folder, so in the next launches you don't have to ask permission again. And the user will have a smoother experience.
[How to persist user folders permission](/articles/persist-and-retrieve-user-folders-access)
## Conclusion
I hope I've helped you understand how the sandbox works and how to read and write files outside of the app container.

Discover how to get read and write permission to user's Mac folders and files in an app with Sandbox enabled.

MacOS

Persist Access to User Folders Across Launches (Part 2)

Read and Write Data in a Sandboxed App (Part 1)