/** * eCryptfs: Linux filesystem encryption layer * * Copyright (C) 1997-2003 Erez Zadok * Copyright (C) 2001-2003 Stony Brook University * Copyright (C) 2004-2007 International Business Machines Corp. * Author(s): Michael A. Halcrow <mahalcro@us.ibm.com> * Michael C. Thompson <mcthomps@us.ibm.com> * Tyler Hicks <tyhicks@ou.edu> * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of the * License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, but * WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA * 02111-1307, USA. */ #include <linux/dcache.h>#include <linux/file.h>#include <linux/module.h>#include <linux/namei.h>#include <linux/skbuff.h>#include <linux/crypto.h>#include <linux/netlink.h>#include <linux/mount.h>#include <linux/dcache.h>#include <linux/pagemap.h>#include <linux/key.h>#include <linux/parser.h>#include <linux/fs_stack.h>#include "ecryptfs_kernel.h" /** * Module parameter that defines the ecryptfs_verbosity level. */int ecryptfs_verbosity = 0; module_param(ecryptfs_verbosity, int, 0);MODULE_PARM_DESC(ecryptfs_verbosity, "Initial verbosity level (0 or 1; defaults to " "0, which is Quiet)"); /** * Module parameter that defines the number of netlink message buffer * elements */unsigned int ecryptfs_message_buf_len = ECRYPTFS_DEFAULT_MSG_CTX_ELEMS; module_param(ecryptfs_message_buf_len, uint, 0);MODULE_PARM_DESC(ecryptfs_message_buf_len, "Number of message buffer elements"); /** * Module parameter that defines the maximum guaranteed amount of time to wait * for a response through netlink. The actual sleep time will be, more than * likely, a small amount greater than this specified value, but only less if * the netlink message successfully arrives. */signed long ecryptfs_message_wait_timeout = ECRYPTFS_MAX_MSG_CTX_TTL / HZ; module_param(ecryptfs_message_wait_timeout, long, 0);MODULE_PARM_DESC(ecryptfs_message_wait_timeout, "Maximum number of seconds that an operation will " "sleep while waiting for a message response from " "userspace"); /** * Module parameter that is an estimate of the maximum number of users * that will be concurrently using eCryptfs. Set this to the right * value to balance performance and memory use. */unsigned int ecryptfs_number_of_users = ECRYPTFS_DEFAULT_NUM_USERS; module_param(ecryptfs_number_of_users, uint, 0);MODULE_PARM_DESC(ecryptfs_number_of_users, "An estimate of the number of " "concurrent users of eCryptfs"); unsigned int ecryptfs_transport = ECRYPTFS_DEFAULT_TRANSPORT; void __ecryptfs_printk(const char *fmt, ...){ va_list args; va_start(args, fmt); if (fmt[1] == '7') { /* KERN_DEBUG */ if (ecryptfs_verbosity >= 1) vprintk(fmt, args); } else vprintk(fmt, args); va_end(args);} /** * ecryptfs_interpose * @lower_dentry: Existing dentry in the lower filesystem * @dentry: ecryptfs' dentry * @sb: ecryptfs's super_block * @flag: If set to true, then d_add is called, else d_instantiate is called * * Interposes upper and lower dentries. * * Returns zero on success; non-zero otherwise */int ecryptfs_interpose(struct dentry *lower_dentry, struct dentry *dentry, struct super_block *sb, int flag){ struct inode *lower_inode; struct inode *inode; int rc = 0; lower_inode = lower_dentry->d_inode; if (lower_inode->i_sb != ecryptfs_superblock_to_lower(sb)) { rc = -EXDEV; goto out; } if (!igrab(lower_inode)) { rc = -ESTALE; goto out; } inode = iget5_locked(sb, (unsigned long)lower_inode, ecryptfs_inode_test, ecryptfs_inode_set, lower_inode); if (!inode) { rc = -EACCES; iput(lower_inode); goto out; } if (inode->i_state & I_NEW) unlock_new_inode(inode); else iput(lower_inode); if (S_ISLNK(lower_inode->i_mode)) inode->i_op = &ecryptfs_symlink_iops; else if (S_ISDIR(lower_inode->i_mode)) inode->i_op = &ecryptfs_dir_iops; if (S_ISDIR(lower_inode->i_mode)) inode->i_fop = &ecryptfs_dir_fops; if (special_file(lower_inode->i_mode)) init_special_inode(inode, lower_inode->i_mode, lower_inode->i_rdev); dentry->d_op = &ecryptfs_dops; if (flag) d_add(dentry, inode); else d_instantiate(dentry, inode); fsstack_copy_attr_all(inode, lower_inode, NULL); /* This size will be overwritten for real files w/ headers and * other metadata */ fsstack_copy_inode_size(inode, lower_inode);out: return rc;} enum { ecryptfs_opt_sig, ecryptfs_opt_ecryptfs_sig, ecryptfs_opt_debug, ecryptfs_opt_ecryptfs_debug, ecryptfs_opt_cipher, ecryptfs_opt_ecryptfs_cipher, ecryptfs_opt_ecryptfs_key_bytes, ecryptfs_opt_passthrough, ecryptfs_opt_xattr_metadata, ecryptfs_opt_encrypted_view, ecryptfs_opt_err }; static match_table_t tokens = { {ecryptfs_opt_sig, "sig=%s"}, {ecryptfs_opt_ecryptfs_sig, "ecryptfs_sig=%s"}, {ecryptfs_opt_debug, "debug=%u"}, {ecryptfs_opt_ecryptfs_debug, "ecryptfs_debug=%u"}, {ecryptfs_opt_cipher, "cipher=%s"}, {ecryptfs_opt_ecryptfs_cipher, "ecryptfs_cipher=%s"}, {ecryptfs_opt_ecryptfs_key_bytes, "ecryptfs_key_bytes=%u"}, {ecryptfs_opt_passthrough, "ecryptfs_passthrough"}, {ecryptfs_opt_xattr_metadata, "ecryptfs_xattr_metadata"}, {ecryptfs_opt_encrypted_view, "ecryptfs_encrypted_view"}, {ecryptfs_opt_err, NULL}}; /** * ecryptfs_verify_version * @version: The version number to confirm * * Returns zero on good version; non-zero otherwise */static int ecryptfs_verify_version(u16 version){ int rc = 0; unsigned char major; unsigned char minor; major = ((version >> 8) & 0xFF); minor = (version & 0xFF); if (major != ECRYPTFS_VERSION_MAJOR) { ecryptfs_printk(KERN_ERR, "Major version number mismatch. " "Expected [%d]; got [%d]\n", ECRYPTFS_VERSION_MAJOR, major); rc = -EINVAL; goto out; } if (minor != ECRYPTFS_VERSION_MINOR) { ecryptfs_printk(KERN_ERR, "Minor version number mismatch. " "Expected [%d]; got [%d]\n", ECRYPTFS_VERSION_MINOR, minor); rc = -EINVAL; goto out; }out: return rc;} /** * ecryptfs_parse_options * @sb: The ecryptfs super block * @options: The options pased to the kernel * * Parse mount options: * debug=N - ecryptfs_verbosity level for debug output * sig=XXX - description(signature) of the key to use * * Returns the dentry object of the lower-level (lower/interposed) * directory; We want to mount our stackable file system on top of * that lower directory. * * The signature of the key to use must be the description of a key * already in the keyring. Mounting will fail if the key can not be * found. * * Returns zero on success; non-zero on error */static int ecryptfs_parse_options(struct super_block *sb, char *options){ char *p; int rc = 0; int sig_set = 0; int cipher_name_set = 0; int cipher_key_bytes; int cipher_key_bytes_set = 0; struct key *auth_tok_key = NULL; struct ecryptfs_auth_tok *auth_tok = NULL; struct ecryptfs_mount_crypt_stat *mount_crypt_stat = &ecryptfs_superblock_to_private(sb)->mount_crypt_stat; substring_t args[MAX_OPT_ARGS]; int token; char *sig_src; char *sig_dst; char *debug_src; char *cipher_name_dst; char *cipher_name_src; char *cipher_key_bytes_src; int cipher_name_len; if (!options) { rc = -EINVAL; goto out; } while ((p = strsep(&options, ",")) != NULL) { if (!*p) continue; token = match_token(p, tokens, args); switch (token) { case ecryptfs_opt_sig: case ecryptfs_opt_ecryptfs_sig: sig_src = args[0].from; sig_dst = mount_crypt_stat->global_auth_tok_sig; memcpy(sig_dst, sig_src, ECRYPTFS_SIG_SIZE_HEX); sig_dst[ECRYPTFS_SIG_SIZE_HEX] = '\0'; ecryptfs_printk(KERN_DEBUG, "The mount_crypt_stat " "global_auth_tok_sig set to: " "[%s]\n", sig_dst); sig_set = 1; break; case ecryptfs_opt_debug: case ecryptfs_opt_ecryptfs_debug: debug_src = args[0].from; ecryptfs_verbosity = (int)simple_strtol(debug_src, &debug_src, 0); ecryptfs_printk(KERN_DEBUG, "Verbosity set to [%d]" "\n", ecryptfs_verbosity); break; case ecryptfs_opt_cipher: case ecryptfs_opt_ecryptfs_cipher: cipher_name_src = args[0].from; cipher_name_dst = mount_crypt_stat-> global_default_cipher_name; strncpy(cipher_name_dst, cipher_name_src, ECRYPTFS_MAX_CIPHER_NAME_SIZE); ecryptfs_printk(KERN_DEBUG, "The mount_crypt_stat " "global_default_cipher_name set to: " "[%s]\n", cipher_name_dst); cipher_name_set = 1; break; case ecryptfs_opt_ecryptfs_key_bytes: cipher_key_bytes_src = args[0].from; cipher_key_bytes = (int)simple_strtol(cipher_key_bytes_src, &cipher_key_bytes_src, 0); mount_crypt_stat->global_default_cipher_key_size = cipher_key_bytes; ecryptfs_printk(KERN_DEBUG, "The mount_crypt_stat " "global_default_cipher_key_size " "set to: [%d]\n", mount_crypt_stat-> global_default_cipher_key_size); cipher_key_bytes_set = 1; break; case ecryptfs_opt_passthrough: mount_crypt_stat->flags |= ECRYPTFS_PLAINTEXT_PASSTHROUGH_ENABLED; break; case ecryptfs_opt_xattr_metadata: mount_crypt_stat->flags |= ECRYPTFS_XATTR_METADATA_ENABLED; break; case ecryptfs_opt_encrypted_view: mount_crypt_stat->flags |= ECRYPTFS_XATTR_METADATA_ENABLED; mount_crypt_stat->flags |= ECRYPTFS_ENCRYPTED_VIEW_ENABLED; break; case ecryptfs_opt_err: default: ecryptfs_printk(KERN_WARNING, "eCryptfs: unrecognized option '%s'\n", p); } } /* Do not support lack of mount-wide signature in 0.1 * release */ if (!sig_set) { rc = -EINVAL; ecryptfs_printk(KERN_ERR, "You must supply a valid " "passphrase auth tok signature as a mount " "parameter; see the eCryptfs README\n"); goto out; } if (!cipher_name_set) { cipher_name_len = strlen(ECRYPTFS_DEFAULT_CIPHER); if (unlikely(cipher_name_len >= ECRYPTFS_MAX_CIPHER_NAME_SIZE)) { rc = -EINVAL; BUG(); goto out; } memcpy(mount_crypt_stat->global_default_cipher_name, ECRYPTFS_DEFAULT_CIPHER, cipher_name_len); mount_crypt_stat->global_default_cipher_name[cipher_name_len] = '\0'; } if (!cipher_key_bytes_set) { mount_crypt_stat->global_default_cipher_key_size = 0; } rc = ecryptfs_process_cipher( &mount_crypt_stat->global_key_tfm, mount_crypt_stat->global_default_cipher_name, &mount_crypt_stat->global_default_cipher_key_size); if (rc) { printk(KERN_ERR "Error attempting to initialize cipher [%s] " "with key size [%Zd] bytes; rc = [%d]\n", mount_crypt_stat->global_default_cipher_name, mount_crypt_stat->global_default_cipher_key_size, rc); mount_crypt_stat->global_key_tfm = NULL; mount_crypt_stat->global_auth_tok_key = NULL; rc = -EINVAL; goto out; } mutex_init(&mount_crypt_stat->global_key_tfm_mutex); ecryptfs_printk(KERN_DEBUG, "Requesting the key with description: " "[%s]\n", mount_crypt_stat->global_auth_tok_sig); /* The reference to this key is held until umount is done The * call to key_put is done in ecryptfs_put_super() */ auth_tok_key = request_key(&key_type_user, mount_crypt_stat->global_auth_tok_sig, NULL); if (!auth_tok_key || IS_ERR(auth_tok_key)) { ecryptfs_printk(KERN_ERR, "Could not find key with " "description: [%s]\n", mount_crypt_stat->global_auth_tok_sig); process_request_key_err(PTR_ERR(auth_tok_key)); rc = -EINVAL; goto out; } auth_tok = ecryptfs_get_key_payload_data(auth_tok_key); if (ecryptfs_verify_version(auth_tok->version)) { ecryptfs_printk(KERN_ERR, "Data structure version mismatch. " "Userspace tools must match eCryptfs kernel " "module with major version [%d] and minor " "version [%d]\n", ECRYPTFS_VERSION_MAJOR, ECRYPTFS_VERSION_MINOR); rc = -EINVAL; goto out; } if (auth_tok->token_type != ECRYPTFS_PASSWORD && auth_tok->token_type != ECRYPTFS_PRIVATE_KEY) { ecryptfs_printk(KERN_ERR, "Invalid auth_tok structure " "returned from key query\n"); rc = -EINVAL; goto out; } mount_crypt_stat->global_auth_tok_key = auth_tok_key; mount_crypt_stat->global_auth_tok = auth_tok;out: return rc;} struct kmem_cache *ecryptfs_sb_info_cache; /** * ecryptfs_fill_super * @sb: The ecryptfs super block * @raw_data: The options passed to mount * @silent: Not used but required by function prototype * * Sets up what we can of the sb, rest is done in ecryptfs_read_super * * Returns zero on success; non-zero otherwise */static intecryptfs_fill_super(struct super_block *sb, void *raw_data, int silent){ int rc = 0; /* Released in ecryptfs_put_super() */ ecryptfs_set_superblock_private(sb, kmem_cache_zalloc(ecryptfs_sb_info_cache, GFP_KERNEL)); if (!ecryptfs_superblock_to_private(sb)) { ecryptfs_printk(KERN_WARNING, "Out of memory\n"); rc = -ENOMEM; goto out; } sb->s_op = &ecryptfs_sops; /* Released through deactivate_super(sb) from get_sb_nodev */ sb->s_root = d_alloc(NULL, &(const struct qstr) { .hash = 0,.name = "/",.len = 1}); if (!sb->s_root) { ecryptfs_printk(KERN_ERR, "d_alloc failed\n"); rc = -ENOMEM; goto out; } sb->s_root->d_op = &ecryptfs_dops; sb->s_root->d_sb = sb; sb->s_root->d_parent = sb->s_root; /* Released in d_release when dput(sb->s_root) is called */ /* through deactivate_super(sb) from get_sb_nodev() */ ecryptfs_set_dentry_private(sb->s_root, kmem_cache_zalloc(ecryptfs_dentry_info_cache, GFP_KERNEL)); if (!ecryptfs_dentry_to_private(sb->s_root)) { ecryptfs_printk(KERN_ERR, "dentry_info_cache alloc failed\n"); rc = -ENOMEM; goto out; } rc = 0;out: /* Should be able to rely on deactivate_super called from * get_sb_nodev */ return rc;} /** * ecryptfs_read_super * @sb: The ecryptfs super block * @dev_name: The path to mount over * * Read the super block of the lower filesystem, and use * ecryptfs_interpose to create our initial inode and super block * struct. */static int ecryptfs_read_super(struct super_block *sb, const char *dev_name){ int rc; struct nameidata nd; struct dentry *lower_root; struct vfsmount *lower_mnt; memset(&nd, 0, sizeof(struct nameidata)); rc = path_lookup(dev_name, LOOKUP_FOLLOW | LOOKUP_DIRECTORY, &nd); if (rc) { ecryptfs_printk(KERN_WARNING, "path_lookup() failed\n"); goto out; } lower_root = nd.dentry; lower_mnt = nd.mnt; ecryptfs_set_superblock_lower(sb, lower_root->d_sb); sb->s_maxbytes = lower_root->d_sb->s_maxbytes; ecryptfs_set_dentry_lower(sb->s_root, lower_root); ecryptfs_set_dentry_lower_mnt(sb->s_root, lower_mnt); if ((rc = ecryptfs_interpose(lower_root, sb->s_root, sb, 0))) goto out_free; rc = 0;Lines 1–500 of 881. Load more
/** * eCryptfs: Linux filesystem encryption layer * * Copyright (C) 1997-2003 Erez Zadok * Copyright (C) 2001-2003 Stony Brook University * Copyright (C) 2004-2007 International Business Machines Corp. * Author(s): Michael A. Halcrow <mahalcro@us.ibm.com> * Michael C. Thompson <mcthomps@us.ibm.com> * Tyler Hicks <tyhicks@ou.edu> * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of the * License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, but * WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA * 02111-1307, USA. */ #include <linux/dcache.h> #include <linux/file.h> #include <linux/module.h> #include <linux/namei.h> #include <linux/skbuff.h> #include <linux/crypto.h> #include <linux/netlink.h> #include <linux/mount.h> #include <linux/dcache.h> #include <linux/pagemap.h> #include <linux/key.h> #include <linux/parser.h> #include <linux/fs_stack.h> #include "ecryptfs_kernel.h" /** * Module parameter that defines the ecryptfs_verbosity level. */ int ecryptfs_verbosity = 0; module_param(ecryptfs_verbosity, int, 0); MODULE_PARM_DESC(ecryptfs_verbosity, "Initial verbosity level (0 or 1; defaults to " "0, which is Quiet)"); /** * Module parameter that defines the number of netlink message buffer * elements */ unsigned int ecryptfs_message_buf_len = ECRYPTFS_DEFAULT_MSG_CTX_ELEMS; module_param(ecryptfs_message_buf_len, uint, 0); MODULE_PARM_DESC(ecryptfs_message_buf_len, "Number of message buffer elements"); /** * Module parameter that defines the maximum guaranteed amount of time to wait * for a response through netlink. The actual sleep time will be, more than * likely, a small amount greater than this specified value, but only less if * the netlink message successfully arrives. */ signed long ecryptfs_message_wait_timeout = ECRYPTFS_MAX_MSG_CTX_TTL / HZ; module_param(ecryptfs_message_wait_timeout, long, 0); MODULE_PARM_DESC(ecryptfs_message_wait_timeout, "Maximum number of seconds that an operation will " "sleep while waiting for a message response from " "userspace"); /** * Module parameter that is an estimate of the maximum number of users * that will be concurrently using eCryptfs. Set this to the right * value to balance performance and memory use. */ unsigned int ecryptfs_number_of_users = ECRYPTFS_DEFAULT_NUM_USERS; module_param(ecryptfs_number_of_users, uint, 0); MODULE_PARM_DESC(ecryptfs_number_of_users, "An estimate of the number of " "concurrent users of eCryptfs"); unsigned int ecryptfs_transport = ECRYPTFS_DEFAULT_TRANSPORT; void __ecryptfs_printk(const char *fmt, ...) { va_list args; va_start(args, fmt); if (fmt[1] == '7') { /* KERN_DEBUG */ if (ecryptfs_verbosity >= 1) vprintk(fmt, args); } else vprintk(fmt, args); va_end(args); } /** * ecryptfs_interpose * @lower_dentry: Existing dentry in the lower filesystem * @dentry: ecryptfs' dentry * @sb: ecryptfs's super_block * @flag: If set to true, then d_add is called, else d_instantiate is called * * Interposes upper and lower dentries. * * Returns zero on success; non-zero otherwise */ int ecryptfs_interpose(struct dentry *lower_dentry, struct dentry *dentry, struct super_block *sb, int flag) { struct inode *lower_inode; struct inode *inode; int rc = 0; lower_inode = lower_dentry->d_inode; if (lower_inode->i_sb != ecryptfs_superblock_to_lower(sb)) { rc = -EXDEV; goto out; } if (!igrab(lower_inode)) { rc = -ESTALE; goto out; } inode = iget5_locked(sb, (unsigned long)lower_inode, ecryptfs_inode_test, ecryptfs_inode_set, lower_inode); if (!inode) { rc = -EACCES; iput(lower_inode); goto out; } if (inode->i_state & I_NEW) unlock_new_inode(inode); else iput(lower_inode); if (S_ISLNK(lower_inode->i_mode)) inode->i_op = &ecryptfs_symlink_iops; else if (S_ISDIR(lower_inode->i_mode)) inode->i_op = &ecryptfs_dir_iops; if (S_ISDIR(lower_inode->i_mode)) inode->i_fop = &ecryptfs_dir_fops; if (special_file(lower_inode->i_mode)) init_special_inode(inode, lower_inode->i_mode, lower_inode->i_rdev); dentry->d_op = &ecryptfs_dops; if (flag) d_add(dentry, inode); else d_instantiate(dentry, inode); fsstack_copy_attr_all(inode, lower_inode, NULL); /* This size will be overwritten for real files w/ headers and * other metadata */ fsstack_copy_inode_size(inode, lower_inode); out: return rc; } enum { ecryptfs_opt_sig, ecryptfs_opt_ecryptfs_sig, ecryptfs_opt_debug, ecryptfs_opt_ecryptfs_debug, ecryptfs_opt_cipher, ecryptfs_opt_ecryptfs_cipher, ecryptfs_opt_ecryptfs_key_bytes, ecryptfs_opt_passthrough, ecryptfs_opt_xattr_metadata, ecryptfs_opt_encrypted_view, ecryptfs_opt_err }; static match_table_t tokens = { {ecryptfs_opt_sig, "sig=%s"}, {ecryptfs_opt_ecryptfs_sig, "ecryptfs_sig=%s"}, {ecryptfs_opt_debug, "debug=%u"}, {ecryptfs_opt_ecryptfs_debug, "ecryptfs_debug=%u"}, {ecryptfs_opt_cipher, "cipher=%s"}, {ecryptfs_opt_ecryptfs_cipher, "ecryptfs_cipher=%s"}, {ecryptfs_opt_ecryptfs_key_bytes, "ecryptfs_key_bytes=%u"}, {ecryptfs_opt_passthrough, "ecryptfs_passthrough"}, {ecryptfs_opt_xattr_metadata, "ecryptfs_xattr_metadata"}, {ecryptfs_opt_encrypted_view, "ecryptfs_encrypted_view"}, {ecryptfs_opt_err, NULL} }; /** * ecryptfs_verify_version * @version: The version number to confirm * * Returns zero on good version; non-zero otherwise */ static int ecryptfs_verify_version(u16 version) { int rc = 0; unsigned char major; unsigned char minor; major = ((version >> 8) & 0xFF); minor = (version & 0xFF); if (major != ECRYPTFS_VERSION_MAJOR) { ecryptfs_printk(KERN_ERR, "Major version number mismatch. " "Expected [%d]; got [%d]\n", ECRYPTFS_VERSION_MAJOR, major); rc = -EINVAL; goto out; } if (minor != ECRYPTFS_VERSION_MINOR) { ecryptfs_printk(KERN_ERR, "Minor version number mismatch. " "Expected [%d]; got [%d]\n", ECRYPTFS_VERSION_MINOR, minor); rc = -EINVAL; goto out; } out: return rc; } /** * ecryptfs_parse_options * @sb: The ecryptfs super block * @options: The options pased to the kernel * * Parse mount options: * debug=N - ecryptfs_verbosity level for debug output * sig=XXX - description(signature) of the key to use * * Returns the dentry object of the lower-level (lower/interposed) * directory; We want to mount our stackable file system on top of * that lower directory. * * The signature of the key to use must be the description of a key * already in the keyring. Mounting will fail if the key can not be * found. * * Returns zero on success; non-zero on error */ static int ecryptfs_parse_options(struct super_block *sb, char *options) { char *p; int rc = 0; int sig_set = 0; int cipher_name_set = 0; int cipher_key_bytes; int cipher_key_bytes_set = 0; struct key *auth_tok_key = NULL; struct ecryptfs_auth_tok *auth_tok = NULL; struct ecryptfs_mount_crypt_stat *mount_crypt_stat = &ecryptfs_superblock_to_private(sb)->mount_crypt_stat; substring_t args[MAX_OPT_ARGS]; int token; char *sig_src; char *sig_dst; char *debug_src; char *cipher_name_dst; char *cipher_name_src; char *cipher_key_bytes_src; int cipher_name_len; if (!options) { rc = -EINVAL; goto out; } while ((p = strsep(&options, ",")) != NULL) { if (!*p) continue; token = match_token(p, tokens, args); switch (token) { case ecryptfs_opt_sig: case ecryptfs_opt_ecryptfs_sig: sig_src = args[0].from; sig_dst = mount_crypt_stat->global_auth_tok_sig; memcpy(sig_dst, sig_src, ECRYPTFS_SIG_SIZE_HEX); sig_dst[ECRYPTFS_SIG_SIZE_HEX] = '\0'; ecryptfs_printk(KERN_DEBUG, "The mount_crypt_stat " "global_auth_tok_sig set to: " "[%s]\n", sig_dst); sig_set = 1; break; case ecryptfs_opt_debug: case ecryptfs_opt_ecryptfs_debug: debug_src = args[0].from; ecryptfs_verbosity = (int)simple_strtol(debug_src, &debug_src, 0); ecryptfs_printk(KERN_DEBUG, "Verbosity set to [%d]" "\n", ecryptfs_verbosity); break; case ecryptfs_opt_cipher: case ecryptfs_opt_ecryptfs_cipher: cipher_name_src = args[0].from; cipher_name_dst = mount_crypt_stat-> global_default_cipher_name; strncpy(cipher_name_dst, cipher_name_src, ECRYPTFS_MAX_CIPHER_NAME_SIZE); ecryptfs_printk(KERN_DEBUG, "The mount_crypt_stat " "global_default_cipher_name set to: " "[%s]\n", cipher_name_dst); cipher_name_set = 1; break; case ecryptfs_opt_ecryptfs_key_bytes: cipher_key_bytes_src = args[0].from; cipher_key_bytes = (int)simple_strtol(cipher_key_bytes_src, &cipher_key_bytes_src, 0); mount_crypt_stat->global_default_cipher_key_size = cipher_key_bytes; ecryptfs_printk(KERN_DEBUG, "The mount_crypt_stat " "global_default_cipher_key_size " "set to: [%d]\n", mount_crypt_stat-> global_default_cipher_key_size); cipher_key_bytes_set = 1; break; case ecryptfs_opt_passthrough: mount_crypt_stat->flags |= ECRYPTFS_PLAINTEXT_PASSTHROUGH_ENABLED; break; case ecryptfs_opt_xattr_metadata: mount_crypt_stat->flags |= ECRYPTFS_XATTR_METADATA_ENABLED; break; case ecryptfs_opt_encrypted_view: mount_crypt_stat->flags |= ECRYPTFS_XATTR_METADATA_ENABLED; mount_crypt_stat->flags |= ECRYPTFS_ENCRYPTED_VIEW_ENABLED; break; case ecryptfs_opt_err: default: ecryptfs_printk(KERN_WARNING, "eCryptfs: unrecognized option '%s'\n", p); } } /* Do not support lack of mount-wide signature in 0.1 * release */ if (!sig_set) { rc = -EINVAL; ecryptfs_printk(KERN_ERR, "You must supply a valid " "passphrase auth tok signature as a mount " "parameter; see the eCryptfs README\n"); goto out; } if (!cipher_name_set) { cipher_name_len = strlen(ECRYPTFS_DEFAULT_CIPHER); if (unlikely(cipher_name_len >= ECRYPTFS_MAX_CIPHER_NAME_SIZE)) { rc = -EINVAL; BUG(); goto out; } memcpy(mount_crypt_stat->global_default_cipher_name, ECRYPTFS_DEFAULT_CIPHER, cipher_name_len); mount_crypt_stat->global_default_cipher_name[cipher_name_len] = '\0'; } if (!cipher_key_bytes_set) { mount_crypt_stat->global_default_cipher_key_size = 0; } rc = ecryptfs_process_cipher( &mount_crypt_stat->global_key_tfm, mount_crypt_stat->global_default_cipher_name, &mount_crypt_stat->global_default_cipher_key_size); if (rc) { printk(KERN_ERR "Error attempting to initialize cipher [%s] " "with key size [%Zd] bytes; rc = [%d]\n", mount_crypt_stat->global_default_cipher_name, mount_crypt_stat->global_default_cipher_key_size, rc); mount_crypt_stat->global_key_tfm = NULL; mount_crypt_stat->global_auth_tok_key = NULL; rc = -EINVAL; goto out; } mutex_init(&mount_crypt_stat->global_key_tfm_mutex); ecryptfs_printk(KERN_DEBUG, "Requesting the key with description: " "[%s]\n", mount_crypt_stat->global_auth_tok_sig); /* The reference to this key is held until umount is done The * call to key_put is done in ecryptfs_put_super() */ auth_tok_key = request_key(&key_type_user, mount_crypt_stat->global_auth_tok_sig, NULL); if (!auth_tok_key || IS_ERR(auth_tok_key)) { ecryptfs_printk(KERN_ERR, "Could not find key with " "description: [%s]\n", mount_crypt_stat->global_auth_tok_sig); process_request_key_err(PTR_ERR(auth_tok_key)); rc = -EINVAL; goto out; } auth_tok = ecryptfs_get_key_payload_data(auth_tok_key); if (ecryptfs_verify_version(auth_tok->version)) { ecryptfs_printk(KERN_ERR, "Data structure version mismatch. " "Userspace tools must match eCryptfs kernel " "module with major version [%d] and minor " "version [%d]\n", ECRYPTFS_VERSION_MAJOR, ECRYPTFS_VERSION_MINOR); rc = -EINVAL; goto out; } if (auth_tok->token_type != ECRYPTFS_PASSWORD && auth_tok->token_type != ECRYPTFS_PRIVATE_KEY) { ecryptfs_printk(KERN_ERR, "Invalid auth_tok structure " "returned from key query\n"); rc = -EINVAL; goto out; } mount_crypt_stat->global_auth_tok_key = auth_tok_key; mount_crypt_stat->global_auth_tok = auth_tok; out: return rc; } struct kmem_cache *ecryptfs_sb_info_cache; /** * ecryptfs_fill_super * @sb: The ecryptfs super block * @raw_data: The options passed to mount * @silent: Not used but required by function prototype * * Sets up what we can of the sb, rest is done in ecryptfs_read_super * * Returns zero on success; non-zero otherwise */ static int ecryptfs_fill_super(struct super_block *sb, void *raw_data, int silent) { int rc = 0; /* Released in ecryptfs_put_super() */ ecryptfs_set_superblock_private(sb, kmem_cache_zalloc(ecryptfs_sb_info_cache, GFP_KERNEL)); if (!ecryptfs_superblock_to_private(sb)) { ecryptfs_printk(KERN_WARNING, "Out of memory\n"); rc = -ENOMEM; goto out; } sb->s_op = &ecryptfs_sops; /* Released through deactivate_super(sb) from get_sb_nodev */ sb->s_root = d_alloc(NULL, &(const struct qstr) { .hash = 0,.name = "/",.len = 1}); if (!sb->s_root) { ecryptfs_printk(KERN_ERR, "d_alloc failed\n"); rc = -ENOMEM; goto out; } sb->s_root->d_op = &ecryptfs_dops; sb->s_root->d_sb = sb; sb->s_root->d_parent = sb->s_root; /* Released in d_release when dput(sb->s_root) is called */ /* through deactivate_super(sb) from get_sb_nodev() */ ecryptfs_set_dentry_private(sb->s_root, kmem_cache_zalloc(ecryptfs_dentry_info_cache, GFP_KERNEL)); if (!ecryptfs_dentry_to_private(sb->s_root)) { ecryptfs_printk(KERN_ERR, "dentry_info_cache alloc failed\n"); rc = -ENOMEM; goto out; } rc = 0; out: /* Should be able to rely on deactivate_super called from * get_sb_nodev */ return rc; } /** * ecryptfs_read_super * @sb: The ecryptfs super block * @dev_name: The path to mount over * * Read the super block of the lower filesystem, and use * ecryptfs_interpose to create our initial inode and super block * struct. */ static int ecryptfs_read_super(struct super_block *sb, const char *dev_name) { int rc; struct nameidata nd; struct dentry *lower_root; struct vfsmount *lower_mnt; memset(&nd, 0, sizeof(struct nameidata)); rc = path_lookup(dev_name, LOOKUP_FOLLOW | LOOKUP_DIRECTORY, &nd); if (rc) { ecryptfs_printk(KERN_WARNING, "path_lookup() failed\n"); goto out; } lower_root = nd.dentry; lower_mnt = nd.mnt; ecryptfs_set_superblock_lower(sb, lower_root->d_sb); sb->s_maxbytes = lower_root->d_sb->s_maxbytes; ecryptfs_set_dentry_lower(sb->s_root, lower_root); ecryptfs_set_dentry_lower_mnt(sb->s_root, lower_mnt); if ((rc = ecryptfs_interpose(lower_root, sb->s_root, sb, 0))) goto out_free; rc = 0;