1 /* 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 #ifndef ANDROID_VOLD_CRYPTFS_H 18 #define ANDROID_VOLD_CRYPTFS_H 19 20 /* This structure starts 16,384 bytes before the end of a hardware 21 * partition that is encrypted, or in a separate partition. It's location 22 * is specified by a property set in init.<device>.rc. 23 * The structure allocates 48 bytes for a key, but the real key size is 24 * specified in the struct. Currently, the code is hardcoded to use 128 25 * bit keys. 26 * The fields after salt are only valid in rev 1.1 and later stuctures. 27 * Obviously, the filesystem does not include the last 16 kbytes 28 * of the partition if the crypt_mnt_ftr lives at the end of the 29 * partition. 30 */ 31 32 #include <linux/types.h> 33 #include <stdbool.h> 34 #include <stdint.h> 35 36 #include <cutils/properties.h> 37 38 /* The current cryptfs version */ 39 #define CURRENT_MAJOR_VERSION 1 40 #define CURRENT_MINOR_VERSION 3 41 42 #define CRYPT_FOOTER_OFFSET 0x4000 43 #define CRYPT_FOOTER_TO_PERSIST_OFFSET 0x1000 44 #define CRYPT_PERSIST_DATA_SIZE 0x1000 45 46 #define MAX_CRYPTO_TYPE_NAME_LEN 64 47 48 #define MAX_KEY_LEN 48 49 #define SALT_LEN 16 50 #define SCRYPT_LEN 32 51 52 /* definitions of flags in the structure below */ 53 #define CRYPT_MNT_KEY_UNENCRYPTED 0x1 /* The key for the partition is not encrypted. */ 54 #define CRYPT_ENCRYPTION_IN_PROGRESS \ 55 0x2 /* Encryption partially completed, \ 56 encrypted_upto valid*/ 57 #define CRYPT_INCONSISTENT_STATE \ 58 0x4 /* Set when starting encryption, clear when \ 59 exit cleanly, either through success or \ 60 correctly marked partial encryption */ 61 #define CRYPT_DATA_CORRUPT \ 62 0x8 /* Set when encryption is fine, but the \ 63 underlying volume is corrupt */ 64 #define CRYPT_FORCE_ENCRYPTION \ 65 0x10 /* Set when it is time to encrypt this \ 66 volume on boot. Everything in this \ 67 structure is set up correctly as \ 68 though device is encrypted except \ 69 that the master key is encrypted with the \ 70 default password. */ 71 #define CRYPT_FORCE_COMPLETE \ 72 0x20 /* Set when the above encryption cycle is \ 73 complete. On next cryptkeeper entry, match \ 74 the password. If it matches fix the master \ 75 key and remove this flag. */ 76 77 /* Allowed values for type in the structure below */ 78 #define CRYPT_TYPE_PASSWORD \ 79 0 /* master_key is encrypted with a password \ 80 * Must be zero to be compatible with pre-L \ 81 * devices where type is always password.*/ 82 #define CRYPT_TYPE_DEFAULT \ 83 1 /* master_key is encrypted with default \ 84 * password */ 85 #define CRYPT_TYPE_PATTERN 2 /* master_key is encrypted with a pattern */ 86 #define CRYPT_TYPE_PIN 3 /* master_key is encrypted with a pin */ 87 #define CRYPT_TYPE_MAX_TYPE 3 /* type cannot be larger than this value */ 88 89 #define CRYPT_MNT_MAGIC 0xD0B5B1C4 90 #define PERSIST_DATA_MAGIC 0xE950CD44 91 92 /* Key Derivation Function algorithms */ 93 #define KDF_PBKDF2 1 94 #define KDF_SCRYPT 2 95 /* Algorithms 3 & 4 deprecated before shipping outside of google, so removed */ 96 #define KDF_SCRYPT_KEYMASTER 5 97 98 /* Maximum allowed keymaster blob size. */ 99 #define KEYMASTER_BLOB_SIZE 2048 100 101 /* __le32 and __le16 defined in system/extras/ext4_utils/ext4_utils.h */ 102 #define __le8 unsigned char 103 104 #if !defined(SHA256_DIGEST_LENGTH) 105 #define SHA256_DIGEST_LENGTH 32 106 #endif 107 108 struct crypt_mnt_ftr { 109 __le32 magic; /* See above */ 110 __le16 major_version; 111 __le16 minor_version; 112 __le32 ftr_size; /* in bytes, not including key following */ 113 __le32 flags; /* See above */ 114 __le32 keysize; /* in bytes */ 115 __le32 crypt_type; /* how master_key is encrypted. Must be a 116 * CRYPT_TYPE_XXX value */ 117 __le64 fs_size; /* Size of the encrypted fs, in 512 byte sectors */ 118 __le32 failed_decrypt_count; /* count of # of failed attempts to decrypt and 119 mount, set to 0 on successful mount */ 120 unsigned char crypto_type_name[MAX_CRYPTO_TYPE_NAME_LEN]; /* The type of encryption 121 needed to decrypt this 122 partition, null terminated */ 123 __le32 spare2; /* ignored */ 124 unsigned char master_key[MAX_KEY_LEN]; /* The encrypted key for decrypting the filesystem */ 125 unsigned char salt[SALT_LEN]; /* The salt used for this encryption */ 126 __le64 persist_data_offset[2]; /* Absolute offset to both copies of crypt_persist_data 127 * on device with that info, either the footer of the 128 * real_blkdevice or the metadata partition. */ 129 130 __le32 persist_data_size; /* The number of bytes allocated to each copy of the 131 * persistent data table*/ 132 133 __le8 kdf_type; /* The key derivation function used. */ 134 135 /* scrypt parameters. See www.tarsnap.com/scrypt/scrypt.pdf */ 136 __le8 N_factor; /* (1 << N) */ 137 __le8 r_factor; /* (1 << r) */ 138 __le8 p_factor; /* (1 << p) */ 139 __le64 encrypted_upto; /* If we are in state CRYPT_ENCRYPTION_IN_PROGRESS and 140 we have to stop (e.g. power low) this is the last 141 encrypted 512 byte sector.*/ 142 __le8 hash_first_block[SHA256_DIGEST_LENGTH]; /* When CRYPT_ENCRYPTION_IN_PROGRESS 143 set, hash of first block, used 144 to validate before continuing*/ 145 146 /* key_master key, used to sign the derived key which is then used to generate 147 * the intermediate key 148 * This key should be used for no other purposes! We use this key to sign unpadded 149 * data, which is acceptable but only if the key is not reused elsewhere. */ 150 __le8 keymaster_blob[KEYMASTER_BLOB_SIZE]; 151 __le32 keymaster_blob_size; 152 153 /* Store scrypt of salted intermediate key. When decryption fails, we can 154 check if this matches, and if it does, we know that the problem is with the 155 drive, and there is no point in asking the user for more passwords. 156 157 Note that if any part of this structure is corrupt, this will not match and 158 we will continue to believe the user entered the wrong password. In that 159 case the only solution is for the user to enter a password enough times to 160 force a wipe. 161 162 Note also that there is no need to worry about migration. If this data is 163 wrong, we simply won't recognise a right password, and will continue to 164 prompt. On the first password change, this value will be populated and 165 then we will be OK. 166 */ 167 unsigned char scrypted_intermediate_key[SCRYPT_LEN]; 168 169 /* sha of this structure with this element set to zero 170 Used when encrypting on reboot to validate structure before doing something 171 fatal 172 */ 173 unsigned char sha256[SHA256_DIGEST_LENGTH]; 174 }; 175 176 /* Persistant data that should be available before decryption. 177 * Things like airplane mode, locale and timezone are kept 178 * here and can be retrieved by the CryptKeeper UI to properly 179 * configure the phone before asking for the password 180 * This is only valid if the major and minor version above 181 * is set to 1.1 or higher. 182 * 183 * This is a 4K structure. There are 2 copies, and the code alternates 184 * writing one and then clearing the previous one. The reading 185 * code reads the first valid copy it finds, based on the magic number. 186 * The absolute offset to the first of the two copies is kept in rev 1.1 187 * and higher crypt_mnt_ftr structures. 188 */ 189 struct crypt_persist_entry { 190 char key[PROPERTY_KEY_MAX]; 191 char val[PROPERTY_VALUE_MAX]; 192 }; 193 194 /* Should be exactly 4K in size */ 195 struct crypt_persist_data { 196 __le32 persist_magic; 197 __le32 persist_valid_entries; 198 __le32 persist_spare[30]; 199 struct crypt_persist_entry persist_entry[0]; 200 }; 201 202 #define DATA_MNT_POINT "/data" 203 204 /* Return values for cryptfs_crypto_complete */ 205 #define CRYPTO_COMPLETE_NOT_ENCRYPTED 1 206 #define CRYPTO_COMPLETE_ENCRYPTED 0 207 #define CRYPTO_COMPLETE_BAD_METADATA (-1) 208 #define CRYPTO_COMPLETE_PARTIAL (-2) 209 #define CRYPTO_COMPLETE_INCONSISTENT (-3) 210 #define CRYPTO_COMPLETE_CORRUPT (-4) 211 212 /* Return values for cryptfs_enable_inplace*() */ 213 #define ENABLE_INPLACE_OK 0 214 #define ENABLE_INPLACE_ERR_OTHER (-1) 215 #define ENABLE_INPLACE_ERR_DEV (-2) /* crypto_blkdev issue */ 216 217 /* Return values for cryptfs_getfield */ 218 #define CRYPTO_GETFIELD_OK 0 219 #define CRYPTO_GETFIELD_ERROR_NO_FIELD (-1) 220 #define CRYPTO_GETFIELD_ERROR_OTHER (-2) 221 #define CRYPTO_GETFIELD_ERROR_BUF_TOO_SMALL (-3) 222 223 /* Return values for cryptfs_setfield */ 224 #define CRYPTO_SETFIELD_OK 0 225 #define CRYPTO_SETFIELD_ERROR_OTHER (-1) 226 #define CRYPTO_SETFIELD_ERROR_FIELD_TOO_LONG (-2) 227 #define CRYPTO_SETFIELD_ERROR_VALUE_TOO_LONG (-3) 228 229 /* Return values for persist_del_key */ 230 #define PERSIST_DEL_KEY_OK 0 231 #define PERSIST_DEL_KEY_ERROR_OTHER (-1) 232 #define PERSIST_DEL_KEY_ERROR_NO_FIELD (-2) 233 234 int match_multi_entry(const char* key, const char* field, unsigned index); 235 int wait_and_unmount(const char* mountpoint, bool kill); 236 237 typedef int (*kdf_func)(const char* passwd, const unsigned char* salt, unsigned char* ikey, 238 void* params); 239 240 int cryptfs_crypto_complete(void); 241 int cryptfs_check_passwd(const char* pw); 242 int cryptfs_verify_passwd(const char* pw); 243 int cryptfs_restart(void); 244 int cryptfs_enable(int type, const char* passwd, int no_ui); 245 int cryptfs_changepw(int type, const char* newpw); 246 int cryptfs_enable_default(int no_ui); 247 int cryptfs_setup_ext_volume(const char* label, const char* real_blkdev, const unsigned char* key, 248 char* out_crypto_blkdev); 249 int cryptfs_revert_ext_volume(const char* label); 250 int cryptfs_getfield(const char* fieldname, char* value, int len); 251 int cryptfs_setfield(const char* fieldname, const char* value); 252 int cryptfs_mount_default_encrypted(void); 253 int cryptfs_get_password_type(void); 254 const char* cryptfs_get_password(void); 255 void cryptfs_clear_password(void); 256 int cryptfs_isConvertibleToFBE(void); 257 258 uint32_t cryptfs_get_keysize(); 259 const char* cryptfs_get_crypto_name(); 260 261 #endif /* ANDROID_VOLD_CRYPTFS_H */ 262