Home | History | Annotate | Download | only in vold
      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 /* This structure starts 16,384 bytes before the end of a hardware
     18  * 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.
     24  * Obviously, the filesystem does not include the last 16 kbytes
     25  * of the partition if the crypt_mnt_ftr lives at the end of the
     26  * partition.
     27  */
     28 
     29 #include <stdbool.h>
     30 #include <cutils/properties.h>
     31 
     32 /* The current cryptfs version */
     33 #define CURRENT_MAJOR_VERSION 1
     34 #define CURRENT_MINOR_VERSION 3
     35 
     36 #define CRYPT_FOOTER_OFFSET 0x4000
     37 #define CRYPT_FOOTER_TO_PERSIST_OFFSET 0x1000
     38 #define CRYPT_PERSIST_DATA_SIZE 0x1000
     39 
     40 #define MAX_CRYPTO_TYPE_NAME_LEN 64
     41 
     42 #define MAX_KEY_LEN 48
     43 #define SALT_LEN 16
     44 #define SCRYPT_LEN 32
     45 
     46 /* definitions of flags in the structure below */
     47 #define CRYPT_MNT_KEY_UNENCRYPTED 0x1 /* The key for the partition is not encrypted. */
     48 #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 */
     53 #define CRYPT_DATA_CORRUPT 0x8 /* Set when encryption is fine, but the
     54                                   underlying volume is corrupt */
     55 #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. */
     65 
     66 /* 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 
     76 #define CRYPT_MNT_MAGIC 0xD0B5B1C4
     77 #define PERSIST_DATA_MAGIC 0xE950CD44
     78 
     79 /* Key Derivation Function algorithms */
     80 #define KDF_PBKDF2 1
     81 #define KDF_SCRYPT 2
     82 /* Algorithms 3 & 4 deprecated before shipping outside of google, so removed */
     83 #define KDF_SCRYPT_KEYMASTER 5
     84 
     85 /* Maximum allowed keymaster blob size. */
     86 #define KEYMASTER_BLOB_SIZE 2048
     87 
     88 /* __le32 and __le16 defined in system/extras/ext4_utils/ext4_utils.h */
     89 #define __le8  unsigned char
     90 
     91 #if !defined(SHA256_DIGEST_LENGTH)
     92 #define SHA256_DIGEST_LENGTH 32
     93 #endif
     94 
     95 struct crypt_mnt_ftr {
     96   __le32 magic;         /* See above */
     97   __le16 major_version;
     98   __le16 minor_version;
     99   __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 */
    104   __le64 fs_size;       /* Size of the encrypted fs, in 512 byte sectors */
    105   __le32 failed_decrypt_count; /* count of # of failed attempts to decrypt and
    106                                   mount, set to 0 on successful mount */
    107   unsigned char crypto_type_name[MAX_CRYPTO_TYPE_NAME_LEN]; /* The type of encryption
    108                                                                needed to decrypt this
    109                                                                partition, null terminated */
    110   __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*/
    119 
    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) */
    126   __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*/
    132 
    133   /* key_master key, used to sign the derived key which is then used to generate
    134    * the intermediate key
    135    * 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;
    139 
    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];
    155 
    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];
    161 };
    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  */
    176 struct crypt_persist_entry {
    177   char key[PROPERTY_KEY_MAX];
    178   char val[PROPERTY_VALUE_MAX];
    179 };
    180 
    181 /* Should be exactly 4K in size */
    182 struct 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];
    187 };
    188 
    189 #define DATA_MNT_POINT "/data"
    190 
    191 /* 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 
    199 /* 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 
    204 /* 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 
    221 #ifdef __cplusplus
    222 extern "C" {
    223 #endif
    224 
    225   int wait_and_unmount(const char *mountpoint, bool kill);
    226 
    227   typedef int (*kdf_func)(const char *passwd, const unsigned char *salt,
    228                           unsigned char *ikey, void *params);
    229 
    230   int cryptfs_crypto_complete(void);
    231   int cryptfs_check_passwd(char *pw);
    232   int cryptfs_verify_passwd(char *newpw);
    233   int cryptfs_restart(void);
    234   int cryptfs_enable(char *flag, int type, char *passwd, int no_ui);
    235   int cryptfs_changepw(int type, const char *newpw);
    236   int cryptfs_enable_default(char *flag, int no_ui);
    237   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);
    240   int cryptfs_enable_file();
    241   int cryptfs_getfield(const char *fieldname, char *value, int len);
    242   int cryptfs_setfield(const char *fieldname, const char *value);
    243   int cryptfs_mount_default_encrypted(void);
    244   int cryptfs_get_password_type(void);
    245   const char* cryptfs_get_password(void);
    246   void cryptfs_clear_password(void);
    247   int cryptfs_isConvertibleToFBE(void);
    248 
    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);
    255 
    256 #ifdef __cplusplus
    257 }
    258 #endif
    259