KeychainAccess

KeychainAccess とは Keychain に簡単にアクセスすることができるライブラリのこと。

ユーザのパスワードのような気密性の高いデータは UserDefaults や DB ではなく Keychain に保存することが推奨されている。

その Keychain は使いにくいことで有名だったのだが、KeychainAccess を使うことで簡単に利用することができる。

前回の記事では KeychainAccess を使ってデータ書き込みや読み込みを簡単にするための Extension について解説しました。

Service と Server

KeychainAccess ではインスタンス生成時に引数をつけることでServerかServiceかのどちらかを選択することができます。

ちなみに何もつけなかった場合にはアプリのバンドル ID がそのまま使われるみたいです

今までは慣習的にServerを利用していたのですが、Serviceとの違いは何なのでしょうか？

また、場合によっては一つのサービスについて複数のアカウント情報を保持し、ログイン時などにどちらのアカウントを選択するかユーザに選ばせたいような場合もあります。そのような複数アカウント機能を KeychainAccess で実装するにはどうすればよいでしょうか。

Server

公式ドキュメントにもあるようにウェブサイトでのパスコードの保存に使う。

例えば、以下のようなコードを書いたとしよう。

1
var keychain: Keychain
2
keychain = Keychain(server: "AAA", protocolType: .https)
3
keychain["value"] = "AAA"
4
print(keychain["value"])
5
// -> AAA
6

7
keychain = Keychain(server: "BBB", protocolType: .https)
8
keychain["value"] = "BBB"
9
print(keychain["value"])
10
// -> BBB
11

12
keychain = Keychain(server: "AAA", protocolType: .https)
13
print(keychain["value"])
14
// -> BBB

二つのインスタンスは異なるものなのでAAAの値は保存されそうなのだが、実は上書きされてしまう。

というのも、このserverの値には URL に変換可能な文字列を代入する必要があるからだ。KeychainAccessライブラリの内部でStringからURLに変換される際に、変換不可能な倍にはserverには空文字が割り当てられている。

AAAもBBBも URL に変換不可能なのでどちらもserver=""が割り当てられているのと同じ状態になり、そのため二つは同一のインスタンスになってしまっている。

そのため、データが上書きされてしまっているのだ。

1
var keychain: Keychain
2
keychain = Keychain(server: URL(string: "https://tkgstrator.work")!, protocolType: .https)
3
keychain["value"] = "AAA"
4
print(keychain["value"])
5
// -> AAA
6

7
keychain = Keychain(server: URL(string: "https://tkgstrator.works")!, protocolType: .https)
8
keychain["value"] = "BBB"
9
print(keychain["value"])
10
// -> BBB
11

12
keychain = Keychain(server: URL(string: "https://tkgstrator.work")!, protocolType: .https)
13
print(keychain["value"])
14
// -> AAA

このように URL に変換可能な文字列または直接 URL を指定した場合には正しくデータが保存される。

Service

基本的には Server と同じなのですが、任意の文字列が利用できるという点が異なります。それ以外は全て同じです。

Keychain へのデータ保存

ここを勘違いしてしまっていたのですが、Keychain へのデータの保存は辞書型ではないようです。

KeychainAccess のインスタンスの中身は以下のようになっており、これらが配列として保存されています。

	Server	Service
authenticationType	Enum	Enum
synchronizable	Bool	Bool
accessGroup	BundleID	BundleID
class	Enum	Enum
key	String	String
value	Any	Any
accessibility	Enum	Enum
protocol	Enum	-
server	URL	-
service	-	String

つまり、例えばkeychain["price"] = 100のようなコードを書いたとしてもどこにもkeychain["price"]のデータはないということです。

じゃあどうやって保存されているのかというと、以下のようにkeyがpriceでvalueが100のデータ（正確には上のようにもっといろんなデータが入っているが）が配列に追加されているだけだということです。

1
[
2
    [
3
        "key": "price",
4
        "value": "100",
5
        "server": "tkgstrator.work"
6
    ],
7
    [
8
        "key": "name",
9
        "value": "apple"
10
        "server": "tkgstrator.work"
11
    ],
12
]

これがどう困るかというと、サブアカウントのようなものを利用するときに困ります。

何故なら、このままだとどのアカウントのデータかを区別することができないからです。

値をユニークに保つために、Keychain では同一のkeyをもつことは許されていません。そうすれば単にデータが上書きされてしまうだけです。

1
[
2
    [
3
        "key": "userId",
4
        "value": "XXXXXXXX",
5
        "server": "tkgstrator.work"
6
    ],
7
    [
8
        "key": "userId",
9
        "value": "YYYYYYYY",
10
        "server": "tkgstrator.work"
11
    ]
12
]

単なる配列ならこのようなデータも保存できますが、これは同一のキーなのでどちらか一方しか保存できません。最初に書き込んだ方のデータは失われます。

これの対策として考えられるのがServerないしはServiceの値を変更することです。こうすれば別のデータとして扱えます。

1
var keychain: Keychain
2
keychain = Keychain(server: URL(string: "https://tkgstrator.work/account01")!, protocolType: .https)
3
keychain["userId"] = "XXXXXXXX"
4
print(keychain["value"])
5

6
keychain = Keychain(server: URL(string: "https://tkgstrator.work/account02")!, protocolType: .https)
7
keychain["userId"] = "YYYYYYYY"
8
print(keychain["value"])

つまり、このようにしてしまえば良いわけです。

ただし、この方法は次の観点から実装を見送りました。

Keychain を切り替えるのがめんどくさい
- 切り替えるのは良いとして、そのためのServerなどのリストはどうやって保存するのか
- それも Keychain に入れれば仕様がややこしくなってしまう
アカウント数が増えたときに切り替えるのがめんどくさい　　- アカウント数の分だけ Keychain のインスタンスを用意するのはめんどくさい

構造体を Keychain に保存する

そこで考えたのが、userId = XXXXXXXXのようなデータを保存するのではなく、キーとしてユーザ固有の値を与え、データにユーザ情報を全部入れてしまえばよいのではないかという方法でした。

1
// Before
2
keychain["userId"] = "XXXXXXXX"
3
keychain["password"] = "YYYYYYYY"
4
keychain["balancee"] = "ZZZZZZZZ"
5

6
// After
7
keychain["XXXXXXXX"] = User(password: "YYYYYYYY", balance: "ZZZZZZZZ")

しかし、これはこのままではビルドが通りません。Keychain に保存できるのは Data 型が String 型だと決まっているからです。

Codable を利用する

ですが、Swift には構造体を Data 型に変換するためのプロトコルがあります。

それが当ブログでも何度か取り上げたCodbaleというプロトコルで、これを使えば構造体を JSONEncoder で Data 型に変換できます。

いちいちデータをエンコードしたりデコードしたりはめんどくさいので、Extension を使ってそれらの部分をうまく処理してやりましょう。

1
// Keychianに保存する構造体をCodable準拠にする
2
struct Account: Codable {
3
    var userId: String = ""
4
    var password: String = ""
5
    var membership: Bool = false
6

7
    init() {}
8
}

構造体を Codable にするには単に適合させるだけで良いです。何か特別なことをする必要はありません。

1
// Extension
2
extension Keychain {
3
    func setValue(forKey: String, account: Account) throws -> () {
4
        let encoder: JSONEncoder = {
5
            let encoder = JSONEncoder()
6
            encoder.keyEncodingStrategy = .convertToSnakeCase
7
            return encoder
8
        }()
9

10
        let data = try encoder.encode(account)
11
        try set(data, key: forKey)
12
    }
13

14
    func getValue(forKey: String) throws -> Account {
15
        let decoder: JSONDecoder = {
16
            let decoder = JSONDecoder()
17
            decoder.keyDecodingStrategy = .convertFromSnakeCase
18
            return decoder
19
        }()
20
        guard let data = try getData(forKey) {
21
            return try decoder.decode(Account.self, from: data)
22
        }
23
        throw fatalError()
24
    }
25
}

これはエラーを認めてそれを返すようなメソッドですが、ネットワークからレスポンスを受け取っているわけではないので実際にエラーが発生することは（おそらく殆どない）と思われます。

1
// エラーを握りつぶす場合
2
extension Keychain {
3
    func setValue(forKey: String, account: Account) -> () {
4
        let encoder: JSONEncoder = {
5
            let encoder = JSONEncoder()
6
            encoder.keyEncodingStrategy = .convertToSnakeCase
7
            return encoder
8
        }()
9

10
        guard let data = try? encoder.encode(account) else { return }
11
        try? set(data, key: forKey)
12
    }
13

14
    func getValue(forKey: String) -> Account? {
15
        let decoder: JSONDecoder = {
16
            let decoder = JSONDecoder()
17
            decoder.keyDecodingStrategy = .convertFromSnakeCase
18
            return decoder
19
        }()
20

21
        guard let data = try? getData(forKey) else { return nil }
22
        return try? decoder.decode(Account.self, from: data)
23
    }
24
}

エラーが発生しないようなケースであればtry?でエラーを握りつぶしてしまうのもアリです。

自分の場合はエラーが発生しないケースでしたので、後者を選択しました。

1
extension Keychain {
2
    func removeValue(account: Account) {
3
        try? remove(account.userId)
4
    }
5
}

最後に、データを削除できるようにしておいても良いかもしれません。

使い方

1
let keychain = Keychain(service: "work.tkgstrator")
2

3
// データ読み込み(ない場合はnilが返ってくる)
4
guard let account = keychain.getValue(userId: "tkgling") else { return }
5

6
// データ書き込み
7
let account: Account = Account()
8
keychain.setValue(account: account)

構造体が Nil を許容する場合

構造体にオプショナル型のプロパティをつけても正しく動作しました。

1
struct Account: Codable {
2
    var userId: String?
3
    var password: String?
4
    var membership: Bool
5

6
    init() {}
7
}

ただし、キーだけはオプショナルではダメなので、今回のようにuserIdをキーにする場合は書き込む前にuserIdがnilでないかだけはチェックする必要があります。

1
let keychain = Keychain(service: "work.tkgstrator")
2

3
var account: Account = Account()
4
account.userId = "tkgstrator"
5
keychain.setValue(account: account)
6

7
guard let account = keychain.getValue(userId: "tkgstrator") else { return }
8
print(account)
9
// Account(userId: Optional("tkgstrator"), password: nil, membership: nil)

こうすれば直感的にデータを取得できるので便利でした。

KeychainAccessの理解を深めよう