Date: Wed, 19 Aug 2009 11:39:43 GMT From: Gleb Kurtsou <gk@FreeBSD.org> To: Perforce Change Reviews <perforce@FreeBSD.org> Subject: PERFORCE change 167498 for review Message-ID: <200908191139.n7JBdhAu031755@repoman.freebsd.org>
next in thread | raw e-mail | index | archive | help
http://perforce.freebsd.org/chv.cgi?CH=167498 Change 167498 by gk@gk_h1 on 2009/08/19 11:39:26 use HMAC-SHA512 and HKDF use VMAC-64 for name checksum change encrypted name layout to: [checksum] [tweak] [name] preinitialize keys. store contexts instead of raw keys in struct pefs_key forbid empty passphrases in pefs util add some KASSERTS, eliminate excessive debugging Affected files ... .. //depot/projects/soc2009/gk_pefs/sbin/pefs/pefs_ctl.h#5 edit .. //depot/projects/soc2009/gk_pefs/sbin/pefs/pefs_key.c#5 edit .. //depot/projects/soc2009/gk_pefs/sys/fs/pefs/pefs.h#10 edit .. //depot/projects/soc2009/gk_pefs/sys/fs/pefs/pefs_crypto.c#8 edit .. //depot/projects/soc2009/gk_pefs/sys/fs/pefs/pefs_subr.c#10 edit .. //depot/projects/soc2009/gk_pefs/sys/fs/pefs/pefs_vfsops.c#9 edit .. //depot/projects/soc2009/gk_pefs/sys/fs/pefs/pefs_vnops.c#12 edit .. //depot/projects/soc2009/gk_pefs/sys/fs/pefs/vmac.c#1 add .. //depot/projects/soc2009/gk_pefs/sys/fs/pefs/vmac.h#1 add .. //depot/projects/soc2009/gk_pefs/sys/modules/pefs/Makefile#6 edit Differences ... ==== //depot/projects/soc2009/gk_pefs/sbin/pefs/pefs_ctl.h#5 (text+ko) ==== @@ -26,7 +26,7 @@ * $FreeBSD$ */ -#define PEFS_ALG_DEFAULT PEFS_ALG_SALSA20 +#define PEFS_ALG_DEFAULT PEFS_ALG_AES_CTR #define PEFS_ALG_DEFAULT_KEYBITS 256 #define PEFS_KDF_ITERATIONS 50000 ==== //depot/projects/soc2009/gk_pefs/sbin/pefs/pefs_key.c#5 (text+ko) ==== @@ -160,7 +160,7 @@ !i ? "Enter" : "Reenter", prompt); p = readpassphrase(promptbuf, !i ? buf : buf2, BUFSIZ, RPP_ECHO_OFF | RPP_REQUIRE_TTY); - if (p == NULL) { + if (p == NULL || p[0] == '\0') { bzero(buf, sizeof(buf)); bzero(buf2, sizeof(buf2)); errx(EX_DATAERR, "unable to read passphrase"); ==== //depot/projects/soc2009/gk_pefs/sys/fs/pefs/pefs.h#10 (text+ko) ==== @@ -74,18 +74,20 @@ #define PEFS_NAME_PTON_SIZE(a) (((a) * 3)/4) struct pefs_alg; +struct pefs_ctx; TAILQ_HEAD(pefs_key_head, pefs_key); struct pefs_key { TAILQ_ENTRY(pefs_key) pk_entry; volatile u_int pk_refcnt; + const struct pefs_alg *pk_alg; + struct pefs_ctx *pk_name_csum_ctx; + struct pefs_ctx *pk_name_ctx; + struct pefs_ctx *pk_data_ctx; + struct mtx *pk_entry_lock; int pk_algid; int pk_keybits; - const struct pefs_alg *pk_alg; - struct mtx *pk_entry_lock; - char pk_name[PEFS_KEY_SIZE]; - char pk_data[PEFS_KEY_SIZE]; char pk_keyid[PEFS_KEYID_SIZE]; }; ==== //depot/projects/soc2009/gk_pefs/sys/fs/pefs/pefs_crypto.c#8 (text+ko) ==== @@ -43,6 +43,15 @@ #include <fs/pefs/pefs.h> #include <fs/pefs/pefs_hmac.h> +#include <fs/pefs/vmac.h> + +#define PEFS_CTR_BLOCK_SIZE 16 +#define PEFS_CSUM_BLOCK_SIZE 16 +#define PEFS_BLOCK_ROUND(block, a) (((a) + (block) - 1) & ~((block) - 1)) + +CTASSERT(PEFS_KEY_SIZE <= SHA512_DIGEST_LENGTH); +CTASSERT(PEFS_TWEAK_SIZE == 64/8); +CTASSERT(CAMELLIA_BLOCK_SIZE == PEFS_CTR_BLOCK_SIZE); typedef void algop_keysetup_t(struct pefs_ctx *ctx, const uint8_t *key, uint32_t keybits); typedef void algop_ivsetup_t(struct pefs_ctx *ctx, const uint8_t *iv, uint64_t offset); @@ -56,6 +65,24 @@ algop_crypt_t *pa_crypt; }; +struct pefs_ctr { + uint64_t pctr_offset; + uint32_t pctr_pos; + char pctr_tweak[PEFS_TWEAK_SIZE]; + char pctr_block[PEFS_CTR_BLOCK_SIZE]; +} ; + +struct pefs_ctx { + struct pefs_ctr pctx_ctr; + union { + camellia_ctx pctx_camellia; + rijndael_ctx pctx_aes; + salsa20_ctx pctx_salsa; + struct pefs_hmac_ctx pctx_hmac; + vmac_ctx_t pctx_vmac; + } o; +}; + static algop_keysetup_t pefs_salsa20_keysetup; static algop_ivsetup_t pefs_salsa20_ivsetup; static algop_crypt_t pefs_salsa20_crypt; @@ -90,32 +117,22 @@ 0x5c, 0x83, 0xcb, 0x96, 0x2f, 0xaf, 0x3b, 0xb5, }; -#define MAGIC_KEYGEN_ITERATIONS 16 +/* vmac requirement: first bit of the nonce buffer n must be 0 */ +static const char magic_name_csum_nonce[VMAC_NHBYTES] = { + 0x00, 0xb1, 0xad, 0xd5, 0x5b, 0xf9, 0x10, 0xe1, + 0x0a, 0x25, 0x8a, 0xd3, 0x33, 0x91, 0x8a, 0x1a, +}; -static const char magic_tweak_keygen[PEFS_TWEAK_SIZE] = { +static const char magic_ctxinfo_name_key[PEFS_TWEAK_SIZE] = { 0xc8, 0x27, 0xa3, 0x7e, 0xcf, 0x86, 0x3d, 0x0d, }; -#define PEFS_CTR_BLOCK_SIZE 16 +static const char magic_ctxinfo_name_csum_key[PEFS_TWEAK_SIZE] = { + 0x21, 0xe2, 0x71, 0x0a, 0x4a, 0xe6, 0xfd, 0x64, +}; -CTASSERT(PEFS_TWEAK_SIZE == 64/8); -CTASSERT(CAMELLIA_BLOCK_SIZE == PEFS_CTR_BLOCK_SIZE); - -struct pefs_ctr { - uint64_t pctr_offset; - uint32_t pctr_pos; - char pctr_tweak[PEFS_TWEAK_SIZE]; - char pctr_block[PEFS_CTR_BLOCK_SIZE]; -} ; - -struct pefs_ctx { - struct pefs_ctr pctx_ctr; - union { - camellia_ctx pctx_camellia; - rijndael_ctx pctx_aes; - salsa20_ctx pctx_salsa; - struct pefs_hmac_ctx pctx_hmac; - } o; +static const char magic_ctxinfo_data_key[PEFS_TWEAK_SIZE] = { + 0xe3, 0x74, 0xdc, 0x7f, 0x10, 0x23, 0x55, 0x16, }; static uma_zone_t pefs_ctx_zone; @@ -151,31 +168,63 @@ uma_zfree(pefs_ctx_zone, ctx); } +static inline void +pefs_ctx_cpy(struct pefs_ctx *dst, struct pefs_ctx *src) +{ + *dst = *src; +} + /* - * This is not a key derivation function in common sense! - * Key should be cryptographically strong. + * Use HKDF-Expand() to derive keys, key parameter is supposed to be + * cryptographically strong. + * http://tools.ietf.org/html/draft-krawczyk-hkdf-00 */ static void -pefs_key_generate(struct pefs_ctx *ctx, char *key) +pefs_key_generate(struct pefs_key *pk, const char *masterkey) { - char tweak[PEFS_TWEAK_SIZE]; - int i, j; + struct pefs_ctx *ctx; + char key[PEFS_KEY_SIZE]; + char idx; + + /* Properly initialize contexts as they are used to compare keys. */ + bzero(pk->pk_name_ctx, sizeof(struct pefs_ctx)); + bzero(pk->pk_name_csum_ctx, sizeof(struct pefs_ctx)); + bzero(pk->pk_data_ctx, sizeof(struct pefs_ctx)); + + ctx = pefs_ctx_get(); + + idx = 1; + bzero(key, PEFS_KEY_SIZE); + pefs_hmac_init(&ctx->o.pctx_hmac, masterkey, PEFS_KEY_SIZE); + pefs_hmac_update(&ctx->o.pctx_hmac, key, PEFS_KEY_SIZE); + pefs_hmac_update(&ctx->o.pctx_hmac, magic_ctxinfo_data_key, PEFS_TWEAK_SIZE); + pefs_hmac_update(&ctx->o.pctx_hmac, &idx, sizeof(idx)); + pefs_hmac_final(&ctx->o.pctx_hmac, key, PEFS_KEY_SIZE); + pk->pk_alg->pa_keysetup(pk->pk_data_ctx, key, pk->pk_keybits); + + idx = 2; + pefs_hmac_init(&ctx->o.pctx_hmac, masterkey, PEFS_KEY_SIZE); + pefs_hmac_update(&ctx->o.pctx_hmac, key, PEFS_KEY_SIZE); + pefs_hmac_update(&ctx->o.pctx_hmac, magic_ctxinfo_name_key, PEFS_TWEAK_SIZE); + pefs_hmac_update(&ctx->o.pctx_hmac, &idx, sizeof(idx)); + pefs_hmac_final(&ctx->o.pctx_hmac, key, PEFS_KEY_SIZE); + pk->pk_alg->pa_keysetup(pk->pk_name_ctx, key, pk->pk_keybits); + + idx = 3; + pefs_hmac_init(&ctx->o.pctx_hmac, masterkey, PEFS_KEY_SIZE); + pefs_hmac_update(&ctx->o.pctx_hmac, key, PEFS_KEY_SIZE); + pefs_hmac_update(&ctx->o.pctx_hmac, magic_ctxinfo_name_key, PEFS_TWEAK_SIZE); + pefs_hmac_update(&ctx->o.pctx_hmac, &idx, sizeof(idx)); + pefs_hmac_final(&ctx->o.pctx_hmac, key, PEFS_KEY_SIZE); + vmac_set_key(key, &pk->pk_name_csum_ctx->o.pctx_vmac); - memcpy(tweak, magic_tweak_keygen, PEFS_TWEAK_SIZE); + pefs_ctx_free(ctx); - for (i = 1; i < MAGIC_KEYGEN_ITERATIONS; i++) { - salsa20_keysetup(&ctx->o.pctx_salsa, key, 256); - salsa20_ivsetup(&ctx->o.pctx_salsa, tweak, i * 64); - salsa20_crypt(&ctx->o.pctx_salsa, key, key, PEFS_KEY_SIZE); - for (j = 0; j < PEFS_TWEAK_SIZE; j++) - tweak[j]++; - } } struct pefs_key * pefs_key_get(int alg, int keybits, const char *key, const char *keyid) { - struct pefs_ctx *ctx; struct pefs_key *pk; pk = uma_zalloc(pefs_key_zone, M_WAITOK | M_ZERO); @@ -211,12 +260,11 @@ refcount_init(&pk->pk_refcnt, 1); memcpy(pk->pk_keyid, keyid, PEFS_KEYID_SIZE); - ctx = pefs_ctx_get(); - memcpy(pk->pk_data, key, PEFS_KEY_SIZE); - pefs_key_generate(ctx, pk->pk_data); - memcpy(pk->pk_name, pk->pk_data, PEFS_KEY_SIZE); - pefs_key_generate(ctx, pk->pk_name); - pefs_ctx_free(ctx); + pk->pk_name_ctx = pefs_ctx_get(); + pk->pk_name_csum_ctx = pefs_ctx_get(); + pk->pk_data_ctx = pefs_ctx_get(); + + pefs_key_generate(pk, key); return (pk); } @@ -233,12 +281,11 @@ { if (pk == NULL) return; - if (pk->pk_refcnt == 0) { - PEFSDEBUG("!!!! pefs_key_release: zero reference count\n"); - return; - } if (refcount_release(&pk->pk_refcnt)) { PEFSDEBUG("pefs_key_release: free pk=%p\n", pk); + pefs_ctx_free(pk->pk_name_ctx); + pefs_ctx_free(pk->pk_name_csum_ctx); + pefs_ctx_free(pk->pk_data_ctx); uma_zfree(pefs_key_zone, pk); } } @@ -273,8 +320,7 @@ pos = 0; TAILQ_FOREACH(i, &pm->pm_keys, pk_entry) { if (memcmp(pk->pk_keyid, i->pk_keyid, PEFS_KEYID_SIZE) == 0 || - memcmp(pk->pk_name, i->pk_name, PEFS_KEY_SIZE) == 0 || - memcmp(pk->pk_data, i->pk_data, PEFS_KEY_SIZE) == 0) { + memcmp(pk->pk_data_ctx, i->pk_data_ctx, sizeof(struct pefs_ctx)) == 0) { mtx_unlock(&pm->pm_keys_lock); return (EEXIST); } @@ -331,17 +377,15 @@ struct iovec *iov; int free_ctx = 0; - if (ptk->ptk_key == NULL) { - PEFSDEBUG("!!! %s: NULL ptk_key\n", __func__); - return; - } + KASSERT(ptk->ptk_key != NULL, ("pefs_data_encrypt: key is null")); + if (ctx == NULL) { ctx = pefs_ctx_get(); free_ctx = 1; } alg = ptk->ptk_key->pk_alg; - alg->pa_keysetup(ctx, ptk->ptk_key->pk_data, ptk->ptk_key->pk_keybits); + pefs_ctx_cpy(ctx, ptk->ptk_key->pk_data_ctx); alg->pa_ivsetup(ctx, ptk->ptk_tweak, offset); for (iov = pc->pc_iov; iov < pc->pc_iov + pc->pc_iovcnt; iov++) { alg->pa_crypt(ctx, iov->iov_base, iov->iov_base, @@ -358,33 +402,61 @@ pefs_data_encrypt(ctx, ptk, offset, pc); } +static inline size_t +pefs_name_checksum_psize(size_t namelen) +{ + size_t psize; + + psize = namelen - PEFS_NAME_CSUM_SIZE; + psize = PEFS_NAME_CSUM_SIZE + + PEFS_BLOCK_ROUND(PEFS_CSUM_BLOCK_SIZE, psize); + + return (psize); +} + +/* + * File name layout: [checksum] [tweak] [name] + */ static inline void -pefs_name_checksum(struct pefs_ctx *ctx, struct pefs_key *pk, u_char *csum, const void *mem, size_t count) +pefs_name_checksum(struct pefs_ctx *ctx, struct pefs_key *pk, char *csum, + char *name, size_t size, size_t maxsize) { - pefs_hmac(&ctx->o.pctx_hmac, pk->pk_name, pk->pk_keybits / 8, - mem, count, csum, PEFS_NAME_CSUM_SIZE); + CTASSERT(PEFS_NAME_CSUM_SIZE <= sizeof(uint64_t)); + uint64_t csum_int; + size_t psize; + + psize = pefs_name_checksum_psize(size); + if (psize != size) { + if (maxsize < psize) + panic("pefs_name_checksum: buffer is too small"); + bzero(name + size, psize - size); + } + + pefs_ctx_cpy(ctx, pk->pk_name_csum_ctx); + csum_int = vmac(name + PEFS_NAME_CSUM_SIZE, + size - PEFS_NAME_CSUM_SIZE, + magic_name_csum_nonce, + NULL, &ctx->o.pctx_vmac); + memcpy(csum, &csum_int, PEFS_NAME_CSUM_SIZE); } int pefs_name_encrypt(struct pefs_ctx *ctx, struct pefs_tkey *ptk, const char *plain, size_t plain_len, char *enc, size_t enc_size) { const struct pefs_alg *alg; - char *buf; - size_t size; + char *buf, *buf_name, *buf_tweak; + size_t size, psize; int free_ctx = 0; int r; + KASSERT(ptk->ptk_key != NULL, ("pefs_name_encrypt: key is null")); - if (ptk == NULL || ptk->ptk_key == NULL) { - PEFSDEBUG("!!!! %s: NULL key\n", __func__); - return (-1); - } alg = ptk->ptk_key->pk_alg; size = PEFS_TWEAK_SIZE + plain_len + PEFS_NAME_CSUM_SIZE; if (enc_size < PEFS_NAME_NTOP_SIZE(size)) { - PEFSDEBUG("%s: encname buffer is too short: length=%d; required=%d\n", - __func__, enc_size, PEFS_NAME_NTOP_SIZE(enc_size)); + printf("pefs: name encryption buffer is too small: length %ld, required %ld\n", + enc_size, PEFS_NAME_NTOP_SIZE(size)); return (-1); } @@ -393,25 +465,25 @@ free_ctx = 1; } - buf = malloc(size, M_PEFSBUF, M_WAITOK); + psize = pefs_name_checksum_psize(size); + buf = malloc(psize, M_PEFSBUF, M_WAITOK); - memcpy(buf, ptk->ptk_tweak, PEFS_TWEAK_SIZE); - memcpy(buf + PEFS_TWEAK_SIZE, plain, plain_len); + buf_tweak = buf + PEFS_NAME_CSUM_SIZE; + buf_name = buf + PEFS_NAME_CSUM_SIZE + PEFS_TWEAK_SIZE; + memcpy(buf_tweak, ptk->ptk_tweak, PEFS_TWEAK_SIZE); + memcpy(buf_name, plain, plain_len); - alg->pa_keysetup(ctx, ptk->ptk_key->pk_name, ptk->ptk_key->pk_keybits); + pefs_ctx_cpy(ctx, ptk->ptk_key->pk_name_ctx); alg->pa_ivsetup(ctx, magic_tweak_name, 0); - alg->pa_crypt(ctx, buf, buf, size - PEFS_NAME_CSUM_SIZE); + alg->pa_crypt(ctx, buf_tweak, buf_tweak, size - PEFS_NAME_CSUM_SIZE); - pefs_name_checksum(ctx, ptk->ptk_key, buf + size - PEFS_NAME_CSUM_SIZE, - buf, size - PEFS_NAME_CSUM_SIZE); + pefs_name_checksum(ctx, ptk->ptk_key, buf, buf, size, psize); if (free_ctx) pefs_ctx_free(ctx); r = pefs_name_ntop(buf, size, enc, enc_size); - printf("pefs_name_encrypt: %d; %.*s => %.*s\n", r, plain_len, plain, r, enc); - free(buf, M_PEFSBUF); return (r); @@ -423,25 +495,26 @@ const struct pefs_alg *alg; struct pefs_key *ki; char csum[PEFS_NAME_CSUM_SIZE]; + char *plain_tweak; int free_ctx = 0; int r, ki_rev; - if (pk == NULL) { - PEFSDEBUG("!!!! %s: NULL pk\n", __func__); - return (-1); - } + KASSERT(ptk->ptk_key != NULL, ("pefs_name_decrypt: key is null")); + KASSERT(enc != plain, ("pefs_name_decrypt: ciphertext and plaintext buffers should differ")); + alg = pk->pk_alg; - - if (enc == plain) { - PEFSDEBUG("pefs_name_decrypt: enc == plain\n"); - return (-1); - } r = pefs_name_pton(enc, enc_len, plain, plain_size); if (r < 0 || r <= PEFS_TWEAK_SIZE + PEFS_NAME_CSUM_SIZE) { - PEFSDEBUG("%s: error: r=%d\n", __func__, r); + PEFSDEBUG("pefs_name_decrypt: error: r=%d\n", r); + return (-1); + } + if (plain_size < pefs_name_checksum_psize(r)) { + printf("pefs: name decryption buffer is too small: length %ld, required %ld\n", + plain_size, pefs_name_checksum_psize(r)); return (-1); } + plain_tweak = plain + PEFS_NAME_CSUM_SIZE; if (ctx == NULL) { ctx = pefs_ctx_get(); @@ -451,8 +524,8 @@ ki = pk; ki_rev = 0; do { - pefs_name_checksum(ctx, ki, csum, plain, r - PEFS_NAME_CSUM_SIZE); - if (memcmp(csum, plain + r - PEFS_NAME_CSUM_SIZE, PEFS_NAME_CSUM_SIZE) == 0) + pefs_name_checksum(ctx, ki, csum, plain, r, plain_size); + if (memcmp(csum, plain, PEFS_NAME_CSUM_SIZE) == 0) break; if (!ki_rev) { @@ -473,21 +546,19 @@ if (ki == NULL) return (-1); - alg->pa_keysetup(ctx, ki->pk_name, ki->pk_keybits); + pefs_ctx_cpy(ctx, ki->pk_name_ctx); alg->pa_ivsetup(ctx, magic_tweak_name, 0); - alg->pa_crypt(ctx, plain, plain, r - PEFS_NAME_CSUM_SIZE); + alg->pa_crypt(ctx, plain_tweak, plain_tweak, r - PEFS_NAME_CSUM_SIZE); if (ptk) { ptk->ptk_key = ki; - memcpy(ptk->ptk_tweak, plain, PEFS_TWEAK_SIZE); + memcpy(ptk->ptk_tweak, plain_tweak, PEFS_TWEAK_SIZE); } r -= PEFS_TWEAK_SIZE + PEFS_NAME_CSUM_SIZE; - memcpy(plain, plain + PEFS_TWEAK_SIZE, r); + memcpy(plain, plain + PEFS_NAME_CSUM_SIZE + PEFS_TWEAK_SIZE, r); plain[r] = '\0'; - // PEFSDEBUG("pefs_name_decrypt: %d; %.*s => %.*s\n", r, enc_len, enc, r < 0 ? 0 : r, plain); - return (r); } ==== //depot/projects/soc2009/gk_pefs/sys/fs/pefs/pefs_subr.c#10 (text+ko) ==== @@ -149,16 +149,16 @@ * node found. */ static struct vnode * -pefs_hashins(struct mount *mp, struct pefs_node *xp) +pefs_hashins(struct mount *mp, struct pefs_node *pn) { struct pefs_node_hashhead *hd; struct pefs_node *oxp; struct vnode *ovp; - hd = PEFS_NHASH(xp->pn_lowervp); + hd = PEFS_NHASH(pn->pn_lowervp); mtx_lock(&pefs_hashmtx); LIST_FOREACH(oxp, hd, pn_hash) { - if (oxp->pn_lowervp == xp->pn_lowervp && + if (oxp->pn_lowervp == pn->pn_lowervp && PN_TO_VP(oxp)->v_mount == mp) { /* * See pefs_hashget for a description of this @@ -170,7 +170,7 @@ return (ovp); } } - LIST_INSERT_HEAD(hd, xp, pn_hash); + LIST_INSERT_HEAD(hd, pn, pn_hash); mtx_unlock(&pefs_hashmtx); return (NULLVP); } @@ -183,7 +183,6 @@ PEFSDEBUG("pefs_insmntque_dtr: free node %p\n", pn); vp->v_data = NULL; vp->v_vnlock = &vp->v_lock; - PEFSDEBUG("pefs_insmntque_dtr: pk=%p\n", pn->pn_tkey.ptk_key); pefs_key_release(pn->pn_tkey.ptk_key); uma_zfree(pefs_node_zone, pn); vp->v_op = &dead_vnodeops; @@ -199,7 +198,6 @@ int error, locked, dlocked; int buflen = *encname_len; - PEFSDEBUG("%s: lvp=%p, ldvp=%p, cred=%p\n", __func__, lvp, ldvp, cred); ASSERT_VOP_LOCKED(lvp, "pefs_node_lookup_name"); locked = VOP_ISLOCKED(lvp); if (ldvp) { @@ -214,7 +212,7 @@ VOP_UNLOCK(lvp, 0); nldvp = lvp; error = vn_vptocnp(&nldvp, cred, encname, encname_len); - PEFSDEBUG("%s: vn_vptocnp(dvp) result %d; nldvp=%p; ldvp=%p, len=%d\n", __func__, error, nldvp, ldvp, *encname_len); + PEFSDEBUG("pefs_node_lookup_name: vn_vptocnp(dvp) result %d; nldvp=%p; ldvp=%p, len=%d\n", error, nldvp, ldvp, *encname_len); if (!error) vdrop(nldvp); vrele(lvp); @@ -228,7 +226,6 @@ *encname_len = buflen - *encname_len; if (*encname_len < buflen) encname[*encname_len] = '\0'; - PEFSDEBUG("%s: len=%d %s\n", __func__, *encname_len, encname); return (0); } @@ -250,15 +247,14 @@ return (error); } - PEFSDEBUG("%s: encname_len=%d; encname=%s\n", __func__, encname_len, - encname); + PEFSDEBUG("pefs_node_lookup_key: encname=%.*s\n", encname_len, encname); name_len = pefs_name_decrypt(NULL, pefs_rootkey(pm), ptk, encname, encname_len, namebuf, MAXNAMLEN + 1); if (name_len < 0) { - PEFSDEBUG("%s: not found: %.*s\n", __func__, encname_len, encname); + PEFSDEBUG("pefs_node_lookup_key: not found: %.*s\n", encname_len, encname); error = 0; } else { pefs_key_ref(ptk->ptk_key); @@ -282,7 +278,7 @@ int pefs_node_get(struct mount *mp, struct vnode *lvp, struct vnode *ldvp, struct vnode **vpp, struct ucred *cred, struct pefs_tkey *ptk) { - struct pefs_node *xp; + struct pefs_node *pn; struct vnode *vp; int error; @@ -306,56 +302,54 @@ * might cause a bogus v_data pointer to get dereferenced * elsewhere if MALLOC should block. */ - xp = uma_zalloc(pefs_node_zone, M_WAITOK | M_ZERO); + pn = uma_zalloc(pefs_node_zone, M_WAITOK | M_ZERO); if (ptk != NULL && ptk->ptk_key != NULL) { - xp->pn_tkey = *ptk; - xp->pn_flags = PN_HASKEY; - pefs_key_ref(xp->pn_tkey.ptk_key); + pn->pn_tkey = *ptk; + pn->pn_flags = PN_HASKEY; + pefs_key_ref(pn->pn_tkey.ptk_key); } else if (mp->mnt_data != NULL && pefs_rootkey(VFS_TO_PEFS(mp)) != NULL) { if (cred == NULL) cred = curthread->td_ucred; - error = pefs_node_lookup_key(VFS_TO_PEFS(mp), lvp, ldvp, cred, &xp->pn_tkey); + error = pefs_node_lookup_key(VFS_TO_PEFS(mp), lvp, ldvp, cred, &pn->pn_tkey); if (error) { - uma_zfree(pefs_node_zone, xp); + uma_zfree(pefs_node_zone, pn); return (error); } - if (xp->pn_tkey.ptk_key != NULL) - xp->pn_flags = PN_HASKEY; + if (pn->pn_tkey.ptk_key != NULL) + pn->pn_flags = PN_HASKEY; } - if (xp->pn_tkey.ptk_key != NULL) { - PEFSDEBUG("pefs_node_get: node has key: pk_refcnt=%d\n", xp->pn_tkey.ptk_key->pk_refcnt); - } error = getnewvnode("pefs", mp, &pefs_vnodeops, &vp); if (error) { - pefs_key_release(xp->pn_tkey.ptk_key); - uma_zfree(pefs_node_zone, xp); + pefs_key_release(pn->pn_tkey.ptk_key); + uma_zfree(pefs_node_zone, pn); return (error); } - if (xp->pn_tkey.ptk_key == NULL) - PEFSDEBUG("%s: creating node without key: %p: %p->%p\n", __func__, xp, vp, lvp); + if (pn->pn_tkey.ptk_key == NULL) { + PEFSDEBUG("pefs_node_get: creating node without key: %p: %p->%p\n", pn, vp, lvp); + } - xp->pn_vnode = vp; - xp->pn_lowervp = lvp; + pn->pn_vnode = vp; + pn->pn_lowervp = lvp; vp->v_type = lvp->v_type; - vp->v_data = xp; + vp->v_data = pn; vp->v_vnlock = lvp->v_vnlock; if (vp->v_vnlock == NULL) panic("pefs_node_get: Passed a NULL vnlock.\n"); - error = insmntque1(vp, mp, pefs_insmntque_dtr, xp); + error = insmntque1(vp, mp, pefs_insmntque_dtr, pn); if (error != 0) return (error); /* * Atomically insert our new node into the hash or vget existing * if someone else has beaten us to it. */ - *vpp = pefs_hashins(mp, xp); + *vpp = pefs_hashins(mp, pn); if (*vpp != NULL) { vrele(lvp); vp->v_vnlock = &vp->v_lock; - xp->pn_lowervp = NULL; + pn->pn_lowervp = NULL; vrele(vp); return (0); } @@ -368,14 +362,14 @@ * Remove node from hash and free it. */ void -pefs_node_free(struct pefs_node *xp) +pefs_node_free(struct pefs_node *pn) { - PEFSDEBUG("pefs_node_free: free node %p\n", xp); + PEFSDEBUG("pefs_node_free: free node %p\n", pn); mtx_lock(&pefs_hashmtx); - LIST_REMOVE(xp, pn_hash); + LIST_REMOVE(pn, pn_hash); mtx_unlock(&pefs_hashmtx); - pefs_key_release(xp->pn_tkey.ptk_key); - uma_zfree(pefs_node_zone, xp); + pefs_key_release(pn->pn_tkey.ptk_key); + uma_zfree(pefs_node_zone, pn); } struct pefs_key* @@ -447,7 +441,7 @@ if (pc->pc_iovcnt == 0) panic("pefs_chunk_pullup: chunk is empty"); if (size > pc->pc_size || size > pc->pc_iov[0].iov_len) - panic("pefs_chunk_pullup: size is too large: %u, available %u", + panic("pefs_chunk_pullup: size is too large: %lu, available %u", size, min(pc->pc_size, pc->pc_iov[0].iov_len)); return (pc->pc_iov[0].iov_base); } ==== //depot/projects/soc2009/gk_pefs/sys/fs/pefs/pefs_vfsops.c#9 (text+ko) ==== @@ -245,10 +245,6 @@ int error; struct statfs mstat; - PEFSDEBUG("pefs_statfs(mp = %p, vp = %p->%p)\n", (void *)mp, - (void *)VFS_TO_PEFS(mp)->pm_rootvp, - (void *)PEFS_LOWERVP(VFS_TO_PEFS(mp)->pm_rootvp)); - bzero(&mstat, sizeof(mstat)); error = VFS_STATFS(VFS_TO_PEFS(mp)->pm_lowervfs, &mstat); ==== //depot/projects/soc2009/gk_pefs/sys/fs/pefs/pefs_vnops.c#12 (text+ko) ==== @@ -102,7 +102,6 @@ pec->pec_cn.cn_nameptr = pec->pec_buf; pec->pec_cn.cn_namelen = encname_len; pec->pec_cn.cn_consume = 0; - PEFSDEBUG("%s: name=%s len=%d pk=%p\n", __func__, (char*)pec->pec_buf, encname_len, pec->pec_tkey.ptk_key); } static int @@ -122,7 +121,6 @@ else memcpy(pec->pec_tkey.ptk_tweak, tweak, PEFS_TWEAK_SIZE); pec->pec_tkey.ptk_key = pk; - PEFSDEBUG("%s: pk=%p\n", __func__, pk); pec->pec_buf = uma_zalloc(namei_zone, M_WAITOK); r = pefs_name_encrypt(NULL, &pec->pec_tkey, cnp->cn_nameptr, cnp->cn_namelen, pec->pec_buf, MAXPATHLEN); @@ -134,7 +132,6 @@ pec->pec_cn.cn_nameptr = pec->pec_buf; pec->pec_cn.cn_namelen = r; pec->pec_cn.cn_consume = 0; - PEFSDEBUG("%s: cn_flags=%lu\n", __func__, cnp->cn_flags); return (0); } @@ -146,14 +143,15 @@ } static struct dirent* -pefs_enccn_lookup_dirent(struct pefs_key *pk, struct pefs_tkey *ptk, void *mem, size_t sz, char *name, int namelen, char *buf, size_t buf_sz) +pefs_enccn_lookup_dirent(struct pefs_key *pk, struct pefs_tkey *ptk, + void *mem, size_t sz, char *name, int namelen, char *buf, size_t buf_sz) { struct pefs_ctx *ctx; struct dirent *de; int d_namelen; int de_len; - PEFSDEBUG("%s: lookup %.*s (%d)\n", __func__, namelen, name, namelen); + PEFSDEBUG("pefs_enccn_lookup_dirent: lookup %.*s\n", namelen, name); ctx = pefs_ctx_get(); for (de = (struct dirent*) mem; sz > 0; sz -= de_len, @@ -162,13 +160,7 @@ if (pefs_name_skip(de->d_name, de->d_namlen)) continue; d_namelen = pefs_name_decrypt(ctx, pk, ptk, de->d_name, de->d_namlen, buf, buf_sz); -#if 0 - PEFSDEBUG("%s =>; res=%d; %.*s --> %.*s\n", __func__, d_namelen, - de->d_namlen, de->d_name, - d_namelen < 0 ? 0 : d_namelen, buf); -#endif if (d_namelen == namelen && memcmp(name, buf, namelen) == 0) { - PEFSDEBUG("%s: check dirent: %s\n", __func__, name); pefs_ctx_free(ctx); return (de); } @@ -227,7 +219,6 @@ } if (de != NULL) { - PEFSDEBUG("%s: dirent found: %.*s\n", __func__, de->d_namlen, de->d_name); pefs_enccn_init(pec, &ptk, de->d_name, de->d_namlen, cnp); } @@ -246,14 +237,12 @@ int error; error = pefs_enccn_lookup(pec, dvp, cnp); - PEFSDEBUG("%s: lookup error = %d\n", __func__, error); if (error == ENOENT) { struct pefs_key *dpk = pefs_node_key(VP_TO_PN(dvp)); error = pefs_enccn_create(pec, dpk, NULL, cnp); pefs_key_release(dpk); } - PEFSDEBUG("%s: returning = %d\n", __func__, error); return (error); } @@ -265,11 +254,9 @@ MPASS(ptk->ptk_key != NULL); error = pefs_enccn_lookup(pec, dvp, cnp); - PEFSDEBUG("%s: lookup error = %d\n", __func__, error); if (error == ENOENT) { error = pefs_enccn_create(pec, ptk->ptk_key, ptk->ptk_tweak, cnp); } - PEFSDEBUG("%s: returning = %d\n", __func__, error); return (error); } @@ -281,12 +268,11 @@ int error; if (!(pn->pn_flags & PN_HASKEY)) { - PEFSDEBUG("%s: !(pn->pn_flags & PN_HASKEY)\n", __func__); pefs_enccn_init(pec, NULL, cnp->cn_nameptr, cnp->cn_namelen, cnp); return (0); } - PEFSDEBUG("%s: lookup %s\n", __func__, cnp->cn_nameptr); + PEFSDEBUG("pefs_enccn_get: create %s\n", cnp->cn_nameptr); error = pefs_enccn_create(pec, pn->pn_tkey.ptk_key, pn->pn_tkey.ptk_tweak, cnp); return (error); } @@ -306,8 +292,6 @@ struct pefs_node *pn; int error; - PEFSDEBUG("pefs_flushkey: pk=%p flags=%d\n", pk, flags); - vflush(mp, 0, 0, td); MNT_ILOCK(mp); rootvp = VFS_TO_PEFS(mp)->pm_rootvp; @@ -503,9 +487,8 @@ int nokey_lookup = 0; int error; - PEFSDEBUG("%s: cn_nameiop=%lx, cn_pnbuf=%s; cn_nameptr=%.*s; cn_consume=%d, cn_namelen=%d\n", - __func__, cnp->cn_nameiop, cnp->cn_pnbuf, (int) cnp->cn_namelen, cnp->cn_nameptr, - (int) cnp->cn_consume, (int) cnp->cn_namelen); + PEFSDEBUG("pefs_lookup: cn_nameiop=%lx, cn_nameptr=%.*s\n", + cnp->cn_nameiop, (int)cnp->cn_namelen, cnp->cn_nameptr); if ((flags & ISLASTCN) && ((dvp->v_mount->mnt_flag & MNT_RDONLY) || pefs_no_keys(dvp)) && @@ -541,7 +524,8 @@ error = EROFS; if (error == ENOENT && (cnp->cn_flags & MAKEENTRY) && cnp->cn_nameiop != CREATE) { - PEFSDEBUG("%s: cache_enter negative %.*s\n", __func__, (int) cnp->cn_namelen, cnp->cn_nameptr); + PEFSDEBUG("pefs_lookup: cache_enter negative %.*s\n", + (int)cnp->cn_namelen, cnp->cn_nameptr); cache_enter(dvp, NULLVP, cnp); } else if ((error == 0 || error == EJUSTRETURN) && lvp != NULL) { if (ldvp == lvp) { @@ -554,8 +538,10 @@ vput(lvp); } else { *ap->a_vpp = vp; - if ((cnp->cn_flags & MAKEENTRY) && cnp->cn_nameiop != CREATE) { - PEFSDEBUG("%s: cache_enter %.*s\n", __func__, (int) cnp->cn_namelen, cnp->cn_nameptr); + if ((cnp->cn_flags & MAKEENTRY) && + cnp->cn_nameiop != CREATE) { + PEFSDEBUG("pefs_lookup: cache_enter %.*s\n", + (int)cnp->cn_namelen, cnp->cn_nameptr); cache_enter(dvp, vp, cnp); } } @@ -607,7 +593,6 @@ if (vap->va_size <= o_va.va_size) return (0); - PEFSDEBUG("%s: va_size=%ju; original va_size=%ju\n", __func__, (intmax_t) vap->va_size, (intmax_t) o_va.va_size); if (vap->va_size - o_va.va_size >= INT_MAX) return (EINVAL); size = vap->va_size - o_va.va_size; @@ -620,7 +605,7 @@ pefs_chunk_zero(pc); pefs_data_encrypt(ctx, &pn->pn_tkey, off, pc); puio = pefs_chunk_uio_range(pc, 0, inc, off, UIO_WRITE); - PEFSDEBUG("%s: resizing file; filling with zeros: offset=%jd, resid=%d\n", __func__, off, inc); + PEFSDEBUG("pefs_chsize_vreg: resizing file; filling with zeros: offset=%jd, resid=%d\n", off, inc); error = VOP_WRITE(lvp, puio, 0, cred); if (error) { /* try to reset */ @@ -787,9 +772,6 @@ return (error); } - PEFSDEBUG("%s: %.*s -> %.*s\n", - __func__, (int) fcnp->cn_namelen, fcnp->cn_nameptr, - (int) tcnp->cn_namelen, tcnp->cn_nameptr); ap->a_fcnp = &fenccn.pec_cn; ap->a_tcnp = &tenccn.pec_cn; error = pefs_bypass((struct vop_generic_args *)ap, NULL); @@ -1041,11 +1023,6 @@ if (pefs_name_skip(de->d_name, de->d_namlen)) continue; d_namelen = pefs_name_decrypt(ctx, pk, NULL, de->d_name, de->d_namlen, buf, buf_sz); -#if 0 - PEFSDEBUG("%s =>; res=%d; %.*s --> %.*s\n", __func__, d_namelen, - de->d_namlen, de->d_name, - d_namelen < 0 ? 0 : d_namelen, buf); -#endif if (d_namelen > 0) { /* Do not change d_reclen */ strlcpy(de->d_name, buf, de->d_namlen + 1); @@ -1100,12 +1077,9 @@ error = VOP_READDIR(PEFS_LOWERVP(vp), puio, cred, eofflag, a_ncookies, a_cookies); - PEFSDEBUG("%s => %d; ncookies=%d\n", __func__, error, ap->a_ncookies ? *ap->a_ncookies : -1); - if (error) break; - PEFSDEBUG("%s: size = %d\n", __func__, pc->pc_size - puio->uio_resid); /* Nothing was written.. somehow */ if (pc->pc_size == puio->uio_resid) break; @@ -1133,9 +1107,12 @@ r_cookies = malloc(r_ncookies_max * sizeof(u_long), M_TEMP, M_WAITOK); } - PEFSDEBUG("%s: merge cookies %d + %d\n", __func__, r_ncookies, ncookies); - KASSERT(r_ncookies + ncookies <= r_ncookies_max, ("cookies buffer is too small")); - memcpy(r_cookies + r_ncookies, cookies, ncookies * sizeof(u_long)); + PEFSDEBUG("pefs_readdir: merge cookies %d + %d\n", + r_ncookies, ncookies); + KASSERT(r_ncookies + ncookies <= r_ncookies_max, + ("cookies buffer is too small")); + memcpy(r_cookies + r_ncookies, cookies, + ncookies * sizeof(u_long)); r_ncookies += ncookies; ncookies = 0; free(cookies, M_TEMP); @@ -1173,8 +1150,6 @@ struct pefs_enccn enccn; int error; - PEFSDEBUG("%s: cn_nameiop=%lx, cn_nameptr=%.*s\n", - __func__, cnp->cn_nameiop, (int) cnp->cn_namelen, cnp->cn_nameptr); if (pefs_no_keys(dvp)) return (EROFS); error = pefs_enccn_lookup_create(&enccn, dvp, cnp); @@ -1204,15 +1179,11 @@ return (EROFS); error = pefs_enccn_get(&enccn, vp, cnp); if (error) { - PEFSDEBUG("%s: pefs_enccn_get failed: %d\n", __func__, error); + PEFSDEBUG("pefs_rmdir: pefs_enccn_get failed: %d\n", error); return (error); } - PEFSDEBUG("%s: cn_nameiop=%lx, cn_nameptr=%.*s\n", - __func__, cnp->cn_nameiop, (int) cnp->cn_namelen, cnp->cn_nameptr); ap->a_cnp = &enccn.pec_cn; - PEFSDEBUG("%s: cn_nameiop=%lx, cn_nameptr=%.*s\n", - __func__, ap->a_cnp->cn_nameiop, (int) ap->a_cnp->cn_namelen, ap->a_cnp->cn_nameptr); error = pefs_bypass((struct vop_generic_args *)ap, NULL); ap->a_cnp = cnp; @@ -1241,8 +1212,6 @@ return (error); } - PEFSDEBUG("%s: cn_nameiop=%lx, cn_nameptr=%.*s\n", - __func__, cnp->cn_nameiop, (int) cnp->cn_namelen, cnp->cn_nameptr); ap->a_cnp = &enccn.pec_cn; error = pefs_bypass((struct vop_generic_args *)ap, &enccn.pec_tkey); ap->a_cnp = cnp; @@ -1268,8 +1237,6 @@ return (error); } - PEFSDEBUG("%s: cn_nameiop=%lx, cn_nameptr=%.*s\n", - __func__, cnp->cn_nameiop, (int) cnp->cn_namelen, cnp->cn_nameptr); ap->a_cnp = &enccn.pec_cn; error = pefs_bypass((struct vop_generic_args *)ap, NULL); ap->a_cnp = cnp; @@ -1300,7 +1267,6 @@ return (error); } - PEFSDEBUG("%s: %.*s\n", __func__, (int) cnp->cn_namelen, cnp->cn_nameptr); ap->a_cnp = &enccn.pec_cn; error = pefs_bypass((struct vop_generic_args *)ap, NULL); ap->a_cnp = cnp; @@ -1345,9 +1311,6 @@ pefs_chunk_free(pc); enc_target = NULL; - PEFSDEBUG("%s: %.*s; target=%s penc_target=%s\n", __func__, - (int) cnp->cn_namelen, cnp->cn_nameptr, - target, penc_target); error = VOP_SYMLINK(ldvp, &lvpp, &enccn.pec_cn, ap->a_vap, penc_target); if (!error) { error = pefs_node_get(dvp->v_mount, lvpp, ldvp, &vpp, cnp->cn_cred, &enccn.pec_tkey); @@ -1398,7 +1361,6 @@ } else { pefs_chunk_shrink(pc, target_len); pefs_data_decrypt(NULL, &pn->pn_tkey, 0, pc); - PEFSDEBUG("%s: target=%.*s\n", __func__, target_len, target); uiomove(target, target_len, uio); } pefs_chunk_free(pc); @@ -1423,8 +1385,6 @@ return (error); } - PEFSDEBUG("%s: cn_nameiop=%lx, cn_nameptr=%.*s\n", - __func__, cnp->cn_nameiop, (int) cnp->cn_namelen, cnp->cn_nameptr); ap->a_cnp = &enccn.pec_cn; error = pefs_bypass((struct vop_generic_args *)ap, &enccn.pec_tkey); ap->a_cnp = cnp; @@ -1458,10 +1418,6 @@ if (uio->uio_offset < 0) >>> TRUNCATED FOR MAIL (1000 lines) <<<
Want to link to this message? Use this URL: <https://mail-archive.FreeBSD.org/cgi/mid.cgi?200908191139.n7JBdhAu031755>