blob: fbcec4ec92946071737053912136e30dace8309f [file] [log] [blame]
Ken Sumrall8f869aa2010-12-03 03:47:09 -08001/*
2 * Copyright (C) 2010 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17/* This structure starts 16,384 bytes before the end of a hardware
Ken Sumrall160b4d62013-04-22 12:15:39 -070018 * partition that is encrypted, or in a separate partition. It's location
19 * is specified by a property set in init.<device>.rc.
20 * The structure allocates 48 bytes for a key, but the real key size is
21 * specified in the struct. Currently, the code is hardcoded to use 128
22 * bit keys.
23 * The fields after salt are only valid in rev 1.1 and later stuctures.
Ken Sumrall8f869aa2010-12-03 03:47:09 -080024 * Obviously, the filesystem does not include the last 16 kbytes
Ken Sumrall160b4d62013-04-22 12:15:39 -070025 * of the partition if the crypt_mnt_ftr lives at the end of the
26 * partition.
Ken Sumrall8f869aa2010-12-03 03:47:09 -080027 */
28
Paul Lawrence2f32cda2015-05-05 14:28:25 -070029#include <stdbool.h>
Ken Sumrall160b4d62013-04-22 12:15:39 -070030#include <cutils/properties.h>
31
Kenny Rootc96a5f82013-06-14 12:08:28 -070032/* The current cryptfs version */
33#define CURRENT_MAJOR_VERSION 1
Paul Lawrencef4faa572014-01-29 13:31:03 -080034#define CURRENT_MINOR_VERSION 3
Kenny Rootc96a5f82013-06-14 12:08:28 -070035
Ken Sumrall8f869aa2010-12-03 03:47:09 -080036#define CRYPT_FOOTER_OFFSET 0x4000
Ken Sumrall160b4d62013-04-22 12:15:39 -070037#define CRYPT_FOOTER_TO_PERSIST_OFFSET 0x1000
38#define CRYPT_PERSIST_DATA_SIZE 0x1000
Ken Sumrall8f869aa2010-12-03 03:47:09 -080039
40#define MAX_CRYPTO_TYPE_NAME_LEN 64
41
Ken Sumrall160b4d62013-04-22 12:15:39 -070042#define MAX_KEY_LEN 48
Ken Sumralle8744072011-01-18 22:01:55 -080043#define SALT_LEN 16
Paul Lawrenced0c7b172014-08-08 14:28:10 -070044#define SCRYPT_LEN 32
Ken Sumralle8744072011-01-18 22:01:55 -080045
Ken Sumrall8f869aa2010-12-03 03:47:09 -080046/* definitions of flags in the structure below */
47#define CRYPT_MNT_KEY_UNENCRYPTED 0x1 /* The key for the partition is not encrypted. */
Paul Lawrence6bfed202014-07-28 12:47:22 -070048#define CRYPT_ENCRYPTION_IN_PROGRESS 0x2 /* Encryption partially completed,
49 encrypted_upto valid*/
50#define CRYPT_INCONSISTENT_STATE 0x4 /* Set when starting encryption, clear when
51 exit cleanly, either through success or
52 correctly marked partial encryption */
Paul Lawrence74f29f12014-08-28 15:54:10 -070053#define CRYPT_DATA_CORRUPT 0x8 /* Set when encryption is fine, but the
54 underlying volume is corrupt */
Paul Lawrence3d99eba2015-11-20 07:07:19 -080055#define CRYPT_FORCE_ENCRYPTION 0x10 /* Set when it is time to encrypt this
56 volume on boot. Everything in this
57 structure is set up correctly as
58 though device is encrypted except
59 that the master key is encrypted with the
60 default password. */
61#define CRYPT_FORCE_COMPLETE 0x20 /* Set when the above encryption cycle is
62 complete. On next cryptkeeper entry, match
63 the password. If it matches fix the master
64 key and remove this flag. */
Ken Sumrall8f869aa2010-12-03 03:47:09 -080065
Paul Lawrencef4faa572014-01-29 13:31:03 -080066/* Allowed values for type in the structure below */
67#define CRYPT_TYPE_PASSWORD 0 /* master_key is encrypted with a password
68 * Must be zero to be compatible with pre-L
69 * devices where type is always password.*/
70#define CRYPT_TYPE_DEFAULT 1 /* master_key is encrypted with default
71 * password */
72#define CRYPT_TYPE_PATTERN 2 /* master_key is encrypted with a pattern */
73#define CRYPT_TYPE_PIN 3 /* master_key is encrypted with a pin */
74#define CRYPT_TYPE_MAX_TYPE 3 /* type cannot be larger than this value */
75
Ken Sumrall8f869aa2010-12-03 03:47:09 -080076#define CRYPT_MNT_MAGIC 0xD0B5B1C4
Ken Sumrall160b4d62013-04-22 12:15:39 -070077#define PERSIST_DATA_MAGIC 0xE950CD44
Ken Sumrall8f869aa2010-12-03 03:47:09 -080078
Kenny Rootc4c70f12013-06-14 12:11:38 -070079/* Key Derivation Function algorithms */
80#define KDF_PBKDF2 1
81#define KDF_SCRYPT 2
Paul Lawrencedb3730c2015-02-03 13:08:10 -080082/* Algorithms 3 & 4 deprecated before shipping outside of google, so removed */
Shawn Willdene17a9c42014-09-08 13:04:08 -060083#define KDF_SCRYPT_KEYMASTER 5
Paul Lawrence69f4ebd2014-04-14 12:17:14 -070084
85/* Maximum allowed keymaster blob size. */
86#define KEYMASTER_BLOB_SIZE 2048
Kenny Rootc4c70f12013-06-14 12:11:38 -070087
Mark Salyzyn3e971272014-01-21 13:27:04 -080088/* __le32 and __le16 defined in system/extras/ext4_utils/ext4_utils.h */
Kenny Rootc4c70f12013-06-14 12:11:38 -070089#define __le8 unsigned char
Ken Sumrall8f869aa2010-12-03 03:47:09 -080090
Adam Langley41405bb2015-01-22 16:45:28 -080091#if !defined(SHA256_DIGEST_LENGTH)
92#define SHA256_DIGEST_LENGTH 32
93#endif
94
Ken Sumrall8f869aa2010-12-03 03:47:09 -080095struct crypt_mnt_ftr {
Paul Lawrencef4faa572014-01-29 13:31:03 -080096 __le32 magic; /* See above */
Ken Sumrall8f869aa2010-12-03 03:47:09 -080097 __le16 major_version;
98 __le16 minor_version;
Paul Lawrencef4faa572014-01-29 13:31:03 -080099 __le32 ftr_size; /* in bytes, not including key following */
100 __le32 flags; /* See above */
101 __le32 keysize; /* in bytes */
102 __le32 crypt_type; /* how master_key is encrypted. Must be a
103 * CRYPT_TYPE_XXX value */
Paul Lawrence3d99eba2015-11-20 07:07:19 -0800104 __le64 fs_size; /* Size of the encrypted fs, in 512 byte sectors */
Ken Sumrall8f869aa2010-12-03 03:47:09 -0800105 __le32 failed_decrypt_count; /* count of # of failed attempts to decrypt and
Paul Lawrence87999172014-02-20 12:21:31 -0800106 mount, set to 0 on successful mount */
Ken Sumrall8f869aa2010-12-03 03:47:09 -0800107 unsigned char crypto_type_name[MAX_CRYPTO_TYPE_NAME_LEN]; /* The type of encryption
Paul Lawrence87999172014-02-20 12:21:31 -0800108 needed to decrypt this
109 partition, null terminated */
Ken Sumrall160b4d62013-04-22 12:15:39 -0700110 __le32 spare2; /* ignored */
111 unsigned char master_key[MAX_KEY_LEN]; /* The encrypted key for decrypting the filesystem */
112 unsigned char salt[SALT_LEN]; /* The salt used for this encryption */
113 __le64 persist_data_offset[2]; /* Absolute offset to both copies of crypt_persist_data
114 * on device with that info, either the footer of the
115 * real_blkdevice or the metadata partition. */
116
117 __le32 persist_data_size; /* The number of bytes allocated to each copy of the
118 * persistent data table*/
Kenny Rootc4c70f12013-06-14 12:11:38 -0700119
120 __le8 kdf_type; /* The key derivation function used. */
121
122 /* scrypt parameters. See www.tarsnap.com/scrypt/scrypt.pdf */
123 __le8 N_factor; /* (1 << N) */
124 __le8 r_factor; /* (1 << r) */
125 __le8 p_factor; /* (1 << p) */
Paul Lawrence87999172014-02-20 12:21:31 -0800126 __le64 encrypted_upto; /* If we are in state CRYPT_ENCRYPTION_IN_PROGRESS and
127 we have to stop (e.g. power low) this is the last
128 encrypted 512 byte sector.*/
129 __le8 hash_first_block[SHA256_DIGEST_LENGTH]; /* When CRYPT_ENCRYPTION_IN_PROGRESS
130 set, hash of first block, used
131 to validate before continuing*/
Paul Lawrence69f4ebd2014-04-14 12:17:14 -0700132
Paul Lawrenced0c7b172014-08-08 14:28:10 -0700133 /* key_master key, used to sign the derived key which is then used to generate
134 * the intermediate key
Paul Lawrence69f4ebd2014-04-14 12:17:14 -0700135 * This key should be used for no other purposes! We use this key to sign unpadded
136 * data, which is acceptable but only if the key is not reused elsewhere. */
137 __le8 keymaster_blob[KEYMASTER_BLOB_SIZE];
138 __le32 keymaster_blob_size;
Paul Lawrenced0c7b172014-08-08 14:28:10 -0700139
140 /* Store scrypt of salted intermediate key. When decryption fails, we can
141 check if this matches, and if it does, we know that the problem is with the
142 drive, and there is no point in asking the user for more passwords.
143
144 Note that if any part of this structure is corrupt, this will not match and
145 we will continue to believe the user entered the wrong password. In that
146 case the only solution is for the user to enter a password enough times to
147 force a wipe.
148
149 Note also that there is no need to worry about migration. If this data is
150 wrong, we simply won't recognise a right password, and will continue to
151 prompt. On the first password change, this value will be populated and
152 then we will be OK.
153 */
154 unsigned char scrypted_intermediate_key[SCRYPT_LEN];
Paul Lawrence3d99eba2015-11-20 07:07:19 -0800155
156 /* sha of this structure with this element set to zero
157 Used when encrypting on reboot to validate structure before doing something
158 fatal
159 */
160 unsigned char sha256[SHA256_DIGEST_LENGTH];
Ken Sumrall160b4d62013-04-22 12:15:39 -0700161};
162
163/* Persistant data that should be available before decryption.
164 * Things like airplane mode, locale and timezone are kept
165 * here and can be retrieved by the CryptKeeper UI to properly
166 * configure the phone before asking for the password
167 * This is only valid if the major and minor version above
168 * is set to 1.1 or higher.
169 *
170 * This is a 4K structure. There are 2 copies, and the code alternates
171 * writing one and then clearing the previous one. The reading
172 * code reads the first valid copy it finds, based on the magic number.
173 * The absolute offset to the first of the two copies is kept in rev 1.1
174 * and higher crypt_mnt_ftr structures.
175 */
176struct crypt_persist_entry {
177 char key[PROPERTY_KEY_MAX];
178 char val[PROPERTY_VALUE_MAX];
179};
180
181/* Should be exactly 4K in size */
182struct crypt_persist_data {
183 __le32 persist_magic;
184 __le32 persist_valid_entries;
185 __le32 persist_spare[30];
186 struct crypt_persist_entry persist_entry[0];
Ken Sumrall8f869aa2010-12-03 03:47:09 -0800187};
188
JP Abgrall502dc742013-11-01 13:06:20 -0700189#define DATA_MNT_POINT "/data"
190
Paul Lawrence74f29f12014-08-28 15:54:10 -0700191/* Return values for cryptfs_crypto_complete */
192#define CRYPTO_COMPLETE_NOT_ENCRYPTED 1
193#define CRYPTO_COMPLETE_ENCRYPTED 0
194#define CRYPTO_COMPLETE_BAD_METADATA -1
195#define CRYPTO_COMPLETE_PARTIAL -2
196#define CRYPTO_COMPLETE_INCONSISTENT -3
197#define CRYPTO_COMPLETE_CORRUPT -4
198
JP Abgrall7fc1de82014-10-10 18:43:41 -0700199/* Return values for cryptfs_enable_inplace*() */
200#define ENABLE_INPLACE_OK 0
201#define ENABLE_INPLACE_ERR_OTHER -1
202#define ENABLE_INPLACE_ERR_DEV -2 /* crypto_blkdev issue */
203
Rubin Xu85c01f92014-10-13 12:49:54 +0100204/* Return values for cryptfs_getfield */
205#define CRYPTO_GETFIELD_OK 0
206#define CRYPTO_GETFIELD_ERROR_NO_FIELD -1
207#define CRYPTO_GETFIELD_ERROR_OTHER -2
208#define CRYPTO_GETFIELD_ERROR_BUF_TOO_SMALL -3
209
210/* Return values for cryptfs_setfield */
211#define CRYPTO_SETFIELD_OK 0
212#define CRYPTO_SETFIELD_ERROR_OTHER -1
213#define CRYPTO_SETFIELD_ERROR_FIELD_TOO_LONG -2
214#define CRYPTO_SETFIELD_ERROR_VALUE_TOO_LONG -3
215
216/* Return values for persist_del_key */
217#define PERSIST_DEL_KEY_OK 0
218#define PERSIST_DEL_KEY_ERROR_OTHER -1
219#define PERSIST_DEL_KEY_ERROR_NO_FIELD -2
220
Ken Sumrall8f869aa2010-12-03 03:47:09 -0800221#ifdef __cplusplus
222extern "C" {
223#endif
Kenny Rootc4c70f12013-06-14 12:11:38 -0700224
Paul Lawrence2f32cda2015-05-05 14:28:25 -0700225 int wait_and_unmount(const char *mountpoint, bool kill);
226
Paul Lawrence69f4ebd2014-04-14 12:17:14 -0700227 typedef int (*kdf_func)(const char *passwd, const unsigned char *salt,
Paul Lawrence13486032014-02-03 13:28:11 -0800228 unsigned char *ikey, void *params);
Kenny Rootc4c70f12013-06-14 12:11:38 -0700229
Ken Sumrall7f7dbaa2011-02-01 15:46:41 -0800230 int cryptfs_crypto_complete(void);
Ken Sumrall8f869aa2010-12-03 03:47:09 -0800231 int cryptfs_check_passwd(char *pw);
Ken Sumrall3ad90722011-10-04 20:38:29 -0700232 int cryptfs_verify_passwd(char *newpw);
Ken Sumrall6864b7e2011-01-14 15:20:02 -0800233 int cryptfs_restart(void);
Paul Lawrence569649f2015-09-09 12:13:00 -0700234 int cryptfs_enable(char *flag, int type, char *passwd, int no_ui);
Paul Lawrence13486032014-02-03 13:28:11 -0800235 int cryptfs_changepw(int type, const char *newpw);
Paul Lawrence569649f2015-09-09 12:13:00 -0700236 int cryptfs_enable_default(char *flag, int no_ui);
Jeff Sharkey9c484982015-03-31 10:35:33 -0700237 int cryptfs_setup_ext_volume(const char* label, const char* real_blkdev,
238 const unsigned char* key, int keysize, char* out_crypto_blkdev);
239 int cryptfs_revert_ext_volume(const char* label);
Paul Lawrence731a7a22015-04-28 22:14:15 +0000240 int cryptfs_enable_file();
Rubin Xu85c01f92014-10-13 12:49:54 +0100241 int cryptfs_getfield(const char *fieldname, char *value, int len);
242 int cryptfs_setfield(const char *fieldname, const char *value);
Paul Lawrencef4faa572014-01-29 13:31:03 -0800243 int cryptfs_mount_default_encrypted(void);
244 int cryptfs_get_password_type(void);
Paul Lawrence05335c32015-03-05 09:46:23 -0800245 const char* cryptfs_get_password(void);
Paul Lawrence399317e2014-03-10 13:20:50 -0700246 void cryptfs_clear_password(void);
Paul Lawrence0c247462015-10-29 10:30:57 -0700247 int cryptfs_isConvertibleToFBE(void);
Paul Lawrence731a7a22015-04-28 22:14:15 +0000248
249 // Functions for file encryption to use to inherit our encryption logic
250 int cryptfs_create_default_ftr(struct crypt_mnt_ftr* ftr, int key_length);
251 int cryptfs_get_master_key(struct crypt_mnt_ftr* ftr, const char* password,
252 unsigned char* master_key);
253 int cryptfs_set_password(struct crypt_mnt_ftr* ftr, const char* password,
254 const unsigned char* master_key);
Paul Lawrence0c247462015-10-29 10:30:57 -0700255
Ken Sumrall8f869aa2010-12-03 03:47:09 -0800256#ifdef __cplusplus
257}
258#endif