Skip to contentSkip to conversation

eCryptfs: Public key; transport mechanism

PATCH In review Michael Halcrow 3 participants 9 messages Dec 6, 2006 – Dec 12, 2006

Subsystems (3)
lore
Share & tools
lore
#0 lore raw

PATCH 1/2 eCryptfs: Public key; transport mechanism

This is a re-submission of the same public key patches (updated for 2.6.19-rc6-mm2) that were submitted for review a while back.

This is the transport code for public key functionality in eCryptfs. It manages encryption/decryption request queues with a transport mechanism. Currently, netlink is the only implemented transport.

---

 fs/ecryptfs/ecryptfs_kernel.h |  101 ++++++++
 fs/ecryptfs/messaging.c       |  505 +++++++++++++++++++++++++++++++++++++++++
 fs/ecryptfs/netlink.c         |  255 +++++++++++++++++++++
 include/linux/netlink.h       |    1 
 4 files changed, 859 insertions(+), 3 deletions(-)
 create mode 100644 fs/ecryptfs/messaging.c
 create mode 100644 fs/ecryptfs/netlink.c

fa0a4f8f4601b6c005fcaa628f2d74c6466ec54d

fs/ecryptfs/ecryptfs_kernel.h +98 -3
index 870a65b..2bae036 100644
@@ -6,6 +6,8 @@
  * Copyright (C) 2001-2003 Stony Brook University
  * Copyright (C) 2004-2006 International Business Machines Corp.
  *   Author(s): Michael A. Halcrow <[email protected]>
+ *              Trevor S. Highland <[email protected]>
+ *              Tyler Hicks <[email protected]>
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License as
@@ -34,7 +36,7 @@ #include <linux/scatterlist.h>
 /* Version verification for shared data structures w/ userspace */
 #define ECRYPTFS_VERSION_MAJOR 0x00
 #define ECRYPTFS_VERSION_MINOR 0x04
-#define ECRYPTFS_SUPPORTED_FILE_VERSION 0x01
+#define ECRYPTFS_SUPPORTED_FILE_VERSION 0x02
 /* These flags indicate which features are supported by the kernel
  * module; userspace tools such as the mount helper read
  * ECRYPTFS_VERSIONING_MASK from a sysfs handle in order to determine
@@ -59,10 +61,24 @@ #define ECRYPTFS_PASSWORD_SIG_SIZE ECRYP
 #define ECRYPTFS_MAX_KEY_BYTES 64
 #define ECRYPTFS_MAX_ENCRYPTED_KEY_BYTES 512
 #define ECRYPTFS_DEFAULT_IV_BYTES 16
-#define ECRYPTFS_FILE_VERSION 0x01
+#define ECRYPTFS_FILE_VERSION 0x02
 #define ECRYPTFS_DEFAULT_HEADER_EXTENT_SIZE 8192
 #define ECRYPTFS_DEFAULT_EXTENT_SIZE 4096
 #define ECRYPTFS_MINIMUM_HEADER_EXTENT_SIZE 8192
+#define ECRYPTFS_DEFAULT_MSG_CTX_ELEMS 32
+#define ECRYPTFS_DEFAULT_SEND_TIMEOUT HZ
+#define ECRYPTFS_MAX_MSG_CTX_TTL (HZ*3)
+#define ECRYPTFS_NLMSG_HELO 100
+#define ECRYPTFS_NLMSG_QUIT 101
+#define ECRYPTFS_NLMSG_REQUEST 102
+#define ECRYPTFS_NLMSG_RESPONSE 103
+#define ECRYPTFS_MAX_PKI_NAME_BYTES 16
+#define ECRYPTFS_DEFAULT_NUM_USERS 4
+#define ECRYPTFS_MAX_NUM_USERS 32768
+#define ECRYPTFS_TRANSPORT_NETLINK 0
+#define ECRYPTFS_TRANSPORT_CONNECTOR 1
+#define ECRYPTFS_TRANSPORT_RELAYFS 2
+#define ECRYPTFS_DEFAULT_TRANSPORT ECRYPTFS_TRANSPORT_NETLINK
 
 #define RFC2440_CIPHER_DES3_EDE 0x02
 #define RFC2440_CIPHER_CAST_5 0x03
@@ -76,6 +92,7 @@ #define RFC2440_CIPHER_CAST_6 0x0b
 #define ECRYPTFS_SET_FLAG(flag_bit_vector, flag) (flag_bit_vector |= (flag))
 #define ECRYPTFS_CLEAR_FLAG(flag_bit_vector, flag) (flag_bit_vector &= ~(flag))
 #define ECRYPTFS_CHECK_FLAG(flag_bit_vector, flag) (flag_bit_vector & (flag))
+#define RFC2440_CIPHER_RSA 0x01
 
 /**
  * For convenience, we may need to pass around the encrypted session
@@ -113,6 +130,14 @@ #define ECRYPTFS_SESSION_KEY_ENCRYPTION_
 
 enum ecryptfs_token_types {ECRYPTFS_PASSWORD, ECRYPTFS_PRIVATE_KEY};
 
+struct ecryptfs_private_key {
+	u32 key_size;
+	u32 data_len;
+	u8 signature[ECRYPTFS_PASSWORD_SIG_SIZE + 1];
+	char pki_type[ECRYPTFS_MAX_PKI_NAME_BYTES + 1];
+	u8 data[];
+};
+
 /* May be a password or a private key */
 struct ecryptfs_auth_tok {
 	u16 version; /* 8-bit major and 8-bit minor */
@@ -122,7 +147,7 @@ struct ecryptfs_auth_tok {
 	u8 reserved[32];
 	union {
 		struct ecryptfs_password password;
-		/* Private key is in future eCryptfs releases */
+		struct ecryptfs_private_key private_key;
 	} token;
 } __attribute__ ((packed));
 
@@ -177,8 +202,13 @@ #define ECRYPTFS_DEFAULT_CIPHER "aes"
 #define ECRYPTFS_DEFAULT_KEY_BYTES 16
 #define ECRYPTFS_DEFAULT_CHAINING_MODE CRYPTO_TFM_MODE_CBC
 #define ECRYPTFS_DEFAULT_HASH "md5"
+#define ECRYPTFS_TAG_1_PACKET_TYPE 0x01
 #define ECRYPTFS_TAG_3_PACKET_TYPE 0x8C
 #define ECRYPTFS_TAG_11_PACKET_TYPE 0xED
+#define ECRYPTFS_TAG_64_PACKET_TYPE 0x40
+#define ECRYPTFS_TAG_65_PACKET_TYPE 0x41
+#define ECRYPTFS_TAG_66_PACKET_TYPE 0x42
+#define ECRYPTFS_TAG_67_PACKET_TYPE 0x43
 #define MD5_DIGEST_SIZE 16
 
 /**
@@ -271,6 +301,45 @@ struct ecryptfs_auth_tok_list_item {
 	struct ecryptfs_auth_tok auth_tok;
 };
 
+struct ecryptfs_message {
+	u32 index;
+	u32 data_len;
+	u8 data[];
+};
+
+struct ecryptfs_msg_ctx {
+#define ECRYPTFS_MSG_CTX_STATE_FREE      0x0001
+#define ECRYPTFS_MSG_CTX_STATE_PENDING   0x0002
+#define ECRYPTFS_MSG_CTX_STATE_DONE      0x0003
+	u32 state;
+	unsigned int index;
+	unsigned int counter;
+	struct ecryptfs_message *msg;
+	struct task_struct *task;
+	struct list_head node;
+	struct mutex mux;
+};
+
+extern struct list_head ecryptfs_msg_ctx_free_list;
+extern struct list_head ecryptfs_msg_ctx_alloc_list;
+extern struct mutex ecryptfs_msg_ctx_lists_mux;
+
+#define ecryptfs_uid_hash(uid) \
+        hash_long((unsigned long)uid, ecryptfs_hash_buckets)
+extern struct hlist_head *ecryptfs_daemon_id_hash;
+extern struct mutex ecryptfs_daemon_id_hash_mux;
+extern int ecryptfs_hash_buckets;
+
+extern unsigned int ecryptfs_msg_counter;
+extern struct ecryptfs_msg_ctx *ecryptfs_msg_ctx_arr;
+extern unsigned int ecryptfs_transport;
+
+struct ecryptfs_daemon_id {
+	pid_t pid;
+	uid_t uid;
+	struct hlist_node id_chain;
+};
+
 static inline struct ecryptfs_file_info *
 ecryptfs_file_to_private(struct file *file)
 {
@@ -391,6 +460,9 @@ extern struct super_operations ecryptfs_
 extern struct dentry_operations ecryptfs_dops;
 extern struct address_space_operations ecryptfs_aops;
 extern int ecryptfs_verbosity;
+extern unsigned int ecryptfs_message_buf_len;
+extern signed long ecryptfs_message_wait_timeout;
+extern unsigned int ecryptfs_number_of_users;
 
 extern struct kmem_cache *ecryptfs_auth_tok_list_item_cache;
 extern struct kmem_cache *ecryptfs_file_info_cache;
@@ -487,4 +559,27 @@ int ecryptfs_open_lower_file(struct file
 			     struct vfsmount *lower_mnt, int flags);
 int ecryptfs_close_lower_file(struct file *lower_file);
 
+int ecryptfs_process_helo(unsigned int transport, uid_t uid, pid_t pid);
+int ecryptfs_process_quit(uid_t uid, pid_t pid);
+int ecryptfs_process_response(struct ecryptfs_message *msg, pid_t pid, u32 seq);
+int ecryptfs_send_message(unsigned int transport, char *data, int data_len,
+			  struct ecryptfs_msg_ctx **msg_ctx);
+int ecryptfs_wait_for_response(struct ecryptfs_msg_ctx *msg_ctx,
+			       struct ecryptfs_message **emsg);
+int ecryptfs_init_messaging(unsigned int transport);
+void ecryptfs_release_messaging(unsigned int transport);
+
+int ecryptfs_send_netlink(char *data, int data_len,
+			  struct ecryptfs_msg_ctx *msg_ctx, u16 msg_type,
+			  u16 msg_flags, pid_t daemon_pid);
+int ecryptfs_init_netlink(void);
+void ecryptfs_release_netlink(void);
+
+int ecryptfs_send_connector(char *data, int data_len,
+			    struct ecryptfs_msg_ctx *msg_ctx, u16 msg_type,
+			    u16 msg_flags, pid_t daemon_pid);
+int ecryptfs_init_connector(void);
+void ecryptfs_release_connector(void);
+
+
 #endif /* #ifndef ECRYPTFS_KERNEL_H */
fs/ecryptfs/messaging.c new file +505 -0

505 lines not on this page · raw message

fs/ecryptfs/netlink.c new file +255 -0

255 lines not on this page · raw message

include/linux/netlink.h +1 -0
index b3b9b60..2a20f48 100644
@@ -23,6 +23,7 @@ #define NETLINK_KOBJECT_UEVENT	15	/* Ker
 #define NETLINK_GENERIC		16
 /* leave room for NETLINK_DM (DM Events) */
 #define NETLINK_SCSITRANSPORT	18	/* SCSI Transports */
+#define NETLINK_ECRYPTFS	19
 
 #define MAX_LINKS 32		
 
Signature · 1 line
1.3.3
#1 lore raw

PATCH 2/2 eCryptfs: Public key; packet management

Public key support code. This reads and writes packets in the header that contain public key encrypted file keys. It calls the messaging code in the previous patch to send and receive encryption and decryption request packets from the userspace daemon.

---

 fs/ecryptfs/Makefile          |    2 
 fs/ecryptfs/ecryptfs_kernel.h |    7 
 fs/ecryptfs/keystore.c        |  784 +++++++++++++++++++++++++++++++++++++----
 fs/ecryptfs/main.c            |   49 ++-
 fs/ecryptfs/messaging.c       |   10 -
 fs/ecryptfs/mmap.c            |   91 -----
 fs/ecryptfs/netlink.c         |    4 
 7 files changed, 777 insertions(+), 170 deletions(-)

9979020958c5ee2d0d671cf47144a4a93def964d

fs/ecryptfs/Makefile +1 -1
index ca65624..1f11072 100644
@@ -4,4 +4,4 @@ #
 
 obj-$(CONFIG_ECRYPT_FS) += ecryptfs.o
 
-ecryptfs-objs := dentry.o file.o inode.o main.o super.o mmap.o crypto.o keystore.o debug.o
+ecryptfs-objs := dentry.o file.o inode.o main.o super.o mmap.o crypto.o keystore.o messaging.o netlink.o debug.o
fs/ecryptfs/ecryptfs_kernel.h +5 -2
index 2bae036..3d78107 100644
@@ -32,6 +32,7 @@ #include <keys/user-type.h>
 #include <linux/fs.h>
 #include <linux/namei.h>
 #include <linux/scatterlist.h>
+#include <linux/hash.h>
 
 /* Version verification for shared data structures w/ userspace */
 #define ECRYPTFS_VERSION_MAJOR 0x00
@@ -46,7 +47,8 @@ #define ECRYPTFS_VERSIONING_PUBKEY 0x000
 #define ECRYPTFS_VERSIONING_PLAINTEXT_PASSTHROUGH 0x00000004
 #define ECRYPTFS_VERSIONING_POLICY 0x00000008
 #define ECRYPTFS_VERSIONING_MASK (ECRYPTFS_VERSIONING_PASSPHRASE \
-                                  | ECRYPTFS_VERSIONING_PLAINTEXT_PASSTHROUGH)
+                                  | ECRYPTFS_VERSIONING_PLAINTEXT_PASSTHROUGH \
+                                  | ECRYPTFS_VERSIONING_PUBKEY)
 
 #define ECRYPTFS_MAX_PASSWORD_LENGTH 64
 #define ECRYPTFS_MAX_PASSPHRASE_BYTES ECRYPTFS_MAX_PASSWORD_LENGTH
@@ -561,7 +563,8 @@ int ecryptfs_close_lower_file(struct fil
 
 int ecryptfs_process_helo(unsigned int transport, uid_t uid, pid_t pid);
 int ecryptfs_process_quit(uid_t uid, pid_t pid);
-int ecryptfs_process_response(struct ecryptfs_message *msg, pid_t pid, u32 seq);
+int ecryptfs_process_response(struct ecryptfs_message *msg, uid_t uid,
+			      pid_t pid, u32 seq);
 int ecryptfs_send_message(unsigned int transport, char *data, int data_len,
 			  struct ecryptfs_msg_ctx **msg_ctx);
 int ecryptfs_wait_for_response(struct ecryptfs_msg_ctx *msg_ctx,
fs/ecryptfs/keystore.c +712 -72

973 lines not on this page · raw message

fs/ecryptfs/main.c +47 -2

80 lines not on this page · raw message

fs/ecryptfs/messaging.c +9 -1
index c22b32f..e8ba627 100644
@@ -243,7 +243,8 @@ unlock:
  * userspace. Returns zero upon delivery to desired context element;
  * non-zero upon delivery failure or error.
  */
-int ecryptfs_process_response(struct ecryptfs_message *msg, pid_t pid, u32 seq)
+int ecryptfs_process_response(struct ecryptfs_message *msg, uid_t uid,
+			      pid_t pid, u32 seq)
 {
 	struct ecryptfs_daemon_id *id;
 	struct ecryptfs_msg_ctx *msg_ctx;
@@ -268,6 +269,13 @@ int ecryptfs_process_response(struct ecr
 				msg_ctx->task->euid, pid);
 		goto wake_up;
 	}
+	if (msg_ctx->task->euid != uid) {
+		rc = -EBADMSG;
+		ecryptfs_printk(KERN_WARNING, "Received message from user "
+				"[%d]; expected message from user [%d]\n",
+				uid, msg_ctx->task->euid);
+		goto unlock;
+	}
 	if (id->pid != pid) {
 		rc = -EBADMSG;
 		ecryptfs_printk(KERN_ERR, "User [%d] received a "
fs/ecryptfs/mmap.c +1 -90

103 lines not on this page · raw message

fs/ecryptfs/netlink.c +2 -2
index aba061d..e3aa225 100644
@@ -107,8 +107,8 @@ static int ecryptfs_process_nl_response(
 				"incorrectly specified data length\n");
 		goto out;
 	}
-	rc = ecryptfs_process_response(msg, NETLINK_CREDS(skb)->pid,
-				       nlh->nlmsg_seq);
+	rc = ecryptfs_process_response(msg, NETLINK_CREDS(skb)->uid,
+				       NETLINK_CREDS(skb)->pid, nlh->nlmsg_seq);
 	if (rc)
 		printk(KERN_ERR
 		       "Error processing response message; rc = [%d]\n", rc);
Signature · 1 line
1.3.3
#3 lore raw
In reply to Michael Halcrow
Quoted 2 lines · On Wed, 6 Dec 2006 17:06:38 -0600 Michael Halcrow <[email protected]> wrote:

This is a re-submission of the same public key patches (updated for 2.6.19-rc6-mm2) that were submitted for review a while back.

I made a number of comments last time around, some temperate, some not. I trust the temperate ones were addressed?

Is there really no way in which any other kernel subsystem will ever want functionality of this nature?

Quoted 4 lines

This is the transport code for public key functionality in eCryptfs. It manages encryption/decryption request queues with a transport mechanism. Currently, netlink is the only implemented transport.

I wouldn't view this as an adequate changelog for this sort of work, frankly. Not by a long shot. You've told us very briefly what the patches do. You haven't told us why they do it, nor how they do it.

What design decisions went into this? What options were considered and eliminated and why? etc.

It's just a great lump of code dumped in our laps.

Quoted 1 line

From a quick scan (and I cannot review in more depth because the code is a

complete mystery to this reviewer):

Review

Quoted 2 lines
(quoted diff) +2 -0
+	mutex_init(&ecryptfs_msg_ctx_lists_mux);
+	mutex_lock(&ecryptfs_msg_ctx_lists_mux);

That's a bizarre thing to do. If there's really any other process which can take that mutex, the mutex_init() just trashed it. If there is no other such process, the mutex_lock() is unneeded. There should never be a need to runtime-initialise a static mutex - just use DEFINE_MUTEX.

ecryptfs now has a dependency upon netlink. There's no CONFIG_NETLINK. If CONFIG_NET=n && CONFIG_ECRYPTFS=y is possible, it won't build.

#2 lore raw

Re: [PATCH 2/2] eCryptfs: Public key; packet management

In reply to Michael Halcrow
Quoted 8 lines · On Wed, 6 Dec 2006 17:12:37 -0600 Michael Halcrow <[email protected]> wrote:

Public key support code. This reads and writes packets in the header that contain public key encrypted file keys. It calls the messaging code in the previous patch to send and receive encryption and decryption request packets from the userspace daemon.

...

(quoted diff) +1 -0
+		memset(auth_tok_list_item, 0,

Review

Quoted 10 lines
(quoted diff) +7 -0
+		       sizeof(struct ecryptfs_auth_tok_list_item));
+		kmem_cache_free(ecryptfs_auth_tok_list_item_cache,
+				auth_tok_list_item);
 
...
 
+	memset(auth_tok_list_item, 0,
+	       sizeof(struct ecryptfs_auth_tok_list_item));
+	kmem_cache_free(ecryptfs_auth_tok_list_item_cache,
+			auth_tok_list_item);

That's a bit wasteful of cycles. Or is this done to minimise the exposure of sensitive data? If so, a comment would be in order.

#4 lore raw
In reply to Andrew Morton
Quoted 17 lines · Andrew Morton
Quoted 2 lines · On Wed, 6 Dec 2006 17:06:38 -0600 Michael Halcrow <[email protected]> wrote:

This is a re-submission of the same public key patches (updated for 2.6.19-rc6-mm2) that were submitted for review a while back.

I made a number of comments last time around, some temperate, some not. I trust the temperate ones were addressed?

Is there really no way in which any other kernel subsystem will ever want functionality of this nature?

Quoted 4 lines

This is the transport code for public key functionality in eCryptfs. It manages encryption/decryption request queues with a transport mechanism. Currently, netlink is the only implemented transport.

Quoted 8 lines

I wouldn't view this as an adequate changelog for this sort of work, frankly. Not by a long shot. You've told us very briefly what the patches do. You haven't told us why they do it, nor how they do it.

What design decisions went into this? What options were considered and eliminated and why? etc.

It's just a great lump of code dumped in our laps.

Here is the longer description of the patches that I sent back in August. These comments still apply to the current public key patches. I apologize for not including this content again in the recent submission.

I agree that the messaging code might be of use elsewhere in the kernel in the future. If other kernel developers think that what eCryptfs does for messaging with a userspace daemon is sane, then I can get to work on a patch to extract that into a more general-purpose function.

Mike

----- Forwarded message from Michael Halcrow <[email protected]> -----

From: Michael Halcrow <[email protected]>
To: Andrew Morton <[email protected]>
Cc: [email protected], [email protected], [email protected]
Subject: Re: [PATCH 1/4] eCryptfs: Netlink functions for public key
Reply-To: Michael Halcrow <[email protected]>

Quoted 10 lines · Andrew Morton
Quoted 3 lines · On Thu, 24 Aug 2006 13:18:32 -0500 Michael Halcrow <[email protected]> wrote:

eCryptfs netlink type, header updates, and messaging code to provide support for userspace callout to perform public key operations.

That tells us (with maximum terseness) what it does. We're left to our own devices to work out why it does this, how it does it and why it does it in the way in which it does it? This leads to dumb questions ;)

There is a design document in the works; it's in the ecryptfs-util userspace tarball, under doc/design_doc/. It still needs some fleshing out to encompass userspace components. I'll go ahead and summarize the design for this patch set.

Each inode has a unique File Encryption Key (FEK). Under passphrase, a File Encryption Key Encryption Key (FEKEK) is generated from a salt/passphrase combo on mount. This FEKEK encrypts each FEK and writes it into the header of each file using the packet format specified in RFC 2440. This is all symmetric key encryption, so it can all be done via the kernel crypto API.

These new patches introduce public key encryption of the FEK. There is no asymmetric key encryption support in the kernel crypto API, so eCryptfs pushes the FEK encryption and decryption out to a userspace daemon. After considering our requirements and determining the complexity of using various transport mechanisms, we settled on netlink for this communication.

eCryptfs stores authentication tokens into the kernel keyring. These tokens correlate with individual keys. For passphrase mode of operation, the authentication token contains the symmetric FEKEK. For public key, the authentication token contains a PKI type and an opaque data blob managed by individual PKI modules in userspace.

Each user who opens a file under an eCryptfs partition mounted in public key mode must be running a daemon. That daemon has the user's credentials and has access to all of the keys to which the user should have access. The daemon, when started, initializes the pluggable PKI modules available on the system and registers itself with the eCryptfs kernel module. Userspace utilities register public key authentication tokens into the user session keyring. These authentication tokens correlate key signatures with PKI modules and PKI blobs. The PKI blobs contain PKI-specific information necessary for the PKI module to carry out asymmetric key encryption and decryption.

When the eCryptfs module parses the header of an existing file and finds a Tag 1 (Public Key) packet (see RFC 2440), it reads in the public key identifier (signature). The asymmetrically encrypted FEK is in the Tag 1 packet; eCryptfs puts together a decrypt request packet containing the signature and the encrypted FEK, then it passes it to the daemon registered for the current->euid via a netlink unicast to the PID of the daemon, which was registered at the time the daemon was started by the user.

The daemon actually just makes calls to libecryptfs, which implements request packet parsing and manages PKI modules. libecryptfs grabs the public key authentication token for the given signature from the user session keyring. This auth tok tells libecryptfs which PKI module should receive the request. libecryptfs then makes a decrypt() call to the PKI module, and it passes along the PKI block from the auth tok. The PKI uses the blob to figure out how it should decrypt the data passed to it; it performs the decryption and passes the decrypted data back to libecryptfs. libecryptfs then puts together a reply packet with the decrypted FEK and passes that back to the eCryptfs module.

The eCryptfs module manages these request callouts to userspace code via message context structs. The module maintains an array of message context structs and places the elements of the array on two lists: a free and an allocated list. When eCryptfs wants to make a request, it moves a msg ctx from the free list to the allocated list, sets its state to pending, and fires off the message to the user's registered daemon.

When eCryptfs receives a netlink message (via the callback), it correlates the msg ctx struct in the alloc list with the data in the message itself. The msg->index contains the offset of the array of msg ctx structs. It verifies that the registered daemon PID is the same as the PID of the process that sent the message. It also validates a sequence number between the received packet and the msg ctx. Then, it copies the contents of the message (the reply packet) into the msg ctx struct, sets the state in the msg ctx to done, and wakes up the process that was sleeping while waiting for the reply.

The sleeping process was whatever was performing the sys_open(). This process originally called ecryptfs_send_message(); it is now in ecryptfs_wait_for_response(). When it wakes up and sees that the msg ctx state was set to done, it returns a pointer to the message contents (the reply packet) and returns. If all went well, this packet contains the decrypted FEK, which is then copied into the crypt_stat struct, and life continues as normal.

The case for creation of a new file is very similar, only instead of a decrypt request, eCryptfs sends out an encrypt request.

Quoted 2 lines

- We have a great clod of key mangement code in-kernel. Why is that not suitable (or growable) for public key management?

eCryptfs uses Howells' keyring to store persistent key data and PKI state information. It defers public key cryptographic transformations to userspace code. The userspace data manipulation request really is orthogonal to key management in and of itself. What eCryptfs basically needs is a secure way to communicate with a particular daemon for a particular task doing a syscall, based on the UID. Nothing running under another UID should be able to access that channel of communication.

Quoted 2 lines

- Is it appropriate that new infrastructure for public key management be private to a particular fs?

The messaging.c file contains a lot of code that, perhaps, could be extracted into a separate kernel service. In essence, this would be a sort of request/reply mechanism that would involve a userspace daemon. I am not aware of anything that does quite what eCryptfs does, so I was not aware of any existing tools to do just what we wanted.

Quoted 3 lines

- I see code in there in which the kernel "knows" about specific userspace processes. By uid and pid. What's all that doing and why is it done that way?

I hope the explanation I give above is sufficient.

Quoted 2 lines

What happens if one of these daemons exits without sending a quit message?

There is a stale uid<->pid association in the hash table for that user. When the user registers a new daemon, eCryptfs cleans up the old association and generates a new one. See ecryptfs_process_helo().

<snip>

Quoted 1 line

- _why_ does it use netlink?

Netlink provides the transport mechanism that would minimize the complexity of the implementation, given that we can have multiple daemons (one per user). I explored the possibility of using relayfs, but that would involve having to introduce control channels and a protocol for creating and tearing down channels for the daemons. We do not have to worry about any of that with netlink.

<snip old patch>
----- End forwarded message -----

#5 lore raw
In reply to Andrew Morton
Quoted 40 lines · On Wed, 6 Dec 2006 21:55:55 -0800 Andrew Morton wrote:
Quoted 2 lines · On Wed, 6 Dec 2006 17:06:38 -0600 Michael Halcrow <[email protected]> wrote:

This is a re-submission of the same public key patches (updated for 2.6.19-rc6-mm2) that were submitted for review a while back.

I made a number of comments last time around, some temperate, some not. I trust the temperate ones were addressed?

Is there really no way in which any other kernel subsystem will ever want functionality of this nature?

Quoted 4 lines

This is the transport code for public key functionality in eCryptfs. It manages encryption/decryption request queues with a transport mechanism. Currently, netlink is the only implemented transport.

I wouldn't view this as an adequate changelog for this sort of work, frankly. Not by a long shot. You've told us very briefly what the patches do. You haven't told us why they do it, nor how they do it.

What design decisions went into this? What options were considered and eliminated and why? etc.

It's just a great lump of code dumped in our laps.

Quoted 1 line

From a quick scan (and I cannot review in more depth because the code is a

complete mystery to this reviewer):

Review

Quoted 2 lines
(quoted diff) +2 -0
+	mutex_init(&ecryptfs_msg_ctx_lists_mux);
+	mutex_lock(&ecryptfs_msg_ctx_lists_mux);

That's a bizarre thing to do. If there's really any other process which can take that mutex, the mutex_init() just trashed it. If there is no other such process, the mutex_lock() is unneeded. There should never be a need to runtime-initialise a static mutex - just use DEFINE_MUTEX.

Quoted 2 lines

ecryptfs now has a dependency upon netlink. There's no CONFIG_NETLINK. If CONFIG_NET=n && CONFIG_ECRYPTFS=y is possible, it won't build.

Then shouldn't ECRYPTFS depend on CONFIG_NET ?

---
~Randy

#6 lore raw
Quoted 4 lines · On Sat, 9 Dec 2006 11:04:16 -0800 Randy Dunlap <[email protected]> wrote:
Quoted 2 lines

ecryptfs now has a dependency upon netlink. There's no CONFIG_NETLINK. If CONFIG_NET=n && CONFIG_ECRYPTFS=y is possible, it won't build.

Then shouldn't ECRYPTFS depend on CONFIG_NET ?

yup, that's what I meant..

#7 lore raw
Quoted 8 lines · Andrew Morton
Quoted 3 lines · On Sat, 9 Dec 2006 11:04:16 -0800 Randy Dunlap <[email protected]> wrote:
Quoted 2 lines

ecryptfs now has a dependency upon netlink. There's no CONFIG_NETLINK. If CONFIG_NET=n && CONFIG_ECRYPTFS=y is possible, it won't build.

Then shouldn't ECRYPTFS depend on CONFIG_NET ?

yup, that's what I meant..

That's easy enough to fix, but I was hoping that driver or filesystem maintainers would eventually use & heed Documentation/SubmitChecklist. :(

Signature · 1 line
~Randy
#8 lore raw
In reply to Andrew Morton
Quoted 9 lines · Andrew Morton
Quoted 5 lines · On Sat, 9 Dec 2006 11:04:16 -0800 Randy Dunlap <[email protected]> wrote:
Quoted 3 lines

ecryptfs now has a dependency upon netlink. There's no CONFIG_NETLINK. If CONFIG_NET=n && CONFIG_ECRYPTFS=y is possible, it won't build.

Then shouldn't ECRYPTFS depend on CONFIG_NET ?

yup, that's what I meant..

Add net build dependency to eCryptfs Kconfig entry.

---

 fs/Kconfig |    2 +-
 1 files changed, 1 insertions(+), 1 deletions(-)

b2bc2515b6849154a9598bca4975dc721799954c

fs/Kconfig +1 -1
index c93d82b..17ae291 100644
@@ -1103,7 +1103,7 @@ config AFFS_FS
 
 config ECRYPT_FS
 	tristate "eCrypt filesystem layer support (EXPERIMENTAL)"
-	depends on EXPERIMENTAL && KEYS && CRYPTO
+	depends on EXPERIMENTAL && KEYS && CRYPTO && NET
 	help
 	  Encrypted filesystem that operates on the VFS layer.  See
 	  <file:Documentation/ecryptfs.txt> to learn more about
Signature · 1 line
1.3.3