881 lines · 24.4 KB · C
RawDownload
/** * 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.

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t