Modernize and harden the code path that parses an RPC Reply message.
Unified · Split
| @@ -134,11 +134,12 @@ struct rpc_credops { · 133 unmodified lines | ||
| 134 | 134 | int (*crmarshal)(struct rpc_task *task, |
| 135 | 135 | struct xdr_stream *xdr); |
| 136 | 136 | int (*crrefresh)(struct rpc_task *); |
| 137 | − __be32 * (*crvalidate)(struct rpc_task *, __be32 *); | |
| 137 | + int (*crvalidate)(struct rpc_task *task, | |
| 138 | + struct xdr_stream *xdr); | |
| 138 | 139 | int (*crwrap_req)(struct rpc_task *task, |
| 139 | 140 | struct xdr_stream *xdr); |
| 140 | − int (*crunwrap_resp)(struct rpc_task *, kxdrdproc_t, | |
| 141 | − void *, __be32 *, void *); | |
| 141 | + int (*crunwrap_resp)(struct rpc_task *task, | |
| 142 | + struct xdr_stream *xdr); | |
| 142 | 143 | int (*crkey_timeout)(struct rpc_cred *); |
| 143 | 144 | char * (*crstringify_acceptor)(struct rpc_cred *); |
| 144 | 145 | bool (*crneed_reencode)(struct rpc_task *); |
| @@ -168,12 +169,16 @@ struct rpc_cred * rpcauth_lookupcred(struct rpc_auth *, int); · 23 unmodified lines | ||
| 168 | 169 | void put_rpccred(struct rpc_cred *); |
| 169 | 170 | int rpcauth_marshcred(struct rpc_task *task, |
| 170 | 171 | struct xdr_stream *xdr); |
| 171 | −__be32 * rpcauth_checkverf(struct rpc_task *, __be32 *); | |
| 172 | +int rpcauth_checkverf(struct rpc_task *task, | |
| 173 | + struct xdr_stream *xdr); | |
| 172 | 174 | int rpcauth_wrap_req_encode(struct rpc_task *task, |
| 173 | 175 | struct xdr_stream *xdr); |
| 174 | 176 | int rpcauth_wrap_req(struct rpc_task *task, |
| 175 | 177 | struct xdr_stream *xdr); |
| 176 | −int rpcauth_unwrap_resp(struct rpc_task *task, kxdrdproc_t decode, void *rqstp, __be32 *data, void *obj); | |
| 178 | +int rpcauth_unwrap_resp_decode(struct rpc_task *task, | |
| 179 | + struct xdr_stream *xdr); | |
| 180 | +int rpcauth_unwrap_resp(struct rpc_task *task, | |
| 181 | + struct xdr_stream *xdr); | |
| 177 | 182 | bool rpcauth_xmit_need_reencode(struct rpc_task *task); |
| 178 | 183 | int rpcauth_refreshcred(struct rpc_task *); |
| 179 | 184 | void rpcauth_invalcred(struct rpc_task *); |
| @@ -89,6 +89,7 @@ xdr_buf_init(struct xdr_buf *buf, void *start, size_t len) · 88 unmodified lines | ||
| 89 | 89 | |
| 90 | 90 | #define rpc_auth_null cpu_to_be32(RPC_AUTH_NULL) |
| 91 | 91 | #define rpc_auth_unix cpu_to_be32(RPC_AUTH_UNIX) |
| 92 | +#define rpc_auth_short cpu_to_be32(RPC_AUTH_SHORT) | |
| 92 | 93 | #define rpc_auth_gss cpu_to_be32(RPC_AUTH_GSS) |
| 93 | 94 | |
| 94 | 95 | #define rpc_call cpu_to_be32(RPC_CALL) |
| @@ -17,6 +17,8 @@ · 16 unmodified lines | ||
| 17 | 17 | #include <linux/sunrpc/gss_api.h> |
| 18 | 18 | #include <linux/spinlock.h> |
| 19 | 19 | |
| 20 | +#include <trace/events/sunrpc.h> | |
| 21 | + | |
| 20 | 22 | #define RPC_CREDCACHE_DEFAULT_HASHBITS (4) |
| 21 | 23 | struct rpc_cred_cache { |
| 22 | 24 | struct hlist_head *hashtable; |
| @@ -773,14 +775,6 @@ int rpcauth_marshcred(struct rpc_task *task, struct xdr_stream *xdr) · 750 unmodified lines | ||
| 773 | 775 | return ops->crmarshal(task, xdr); |
| 774 | 776 | } |
| 775 | 777 | |
| 776 | −__be32 * | |
| 777 | −rpcauth_checkverf(struct rpc_task *task, __be32 *p) | |
| 778 | −{ | |
| 779 | − struct rpc_cred *cred = task->tk_rqstp->rq_cred; | |
| 780 | − | |
| 781 | − return cred->cr_ops->crvalidate(task, p); | |
| 782 | −} | |
| 783 | − | |
| 784 | 778 | /** |
| 785 | 779 | * rpcauth_wrap_req_encode - XDR encode the RPC procedure |
| 786 | 780 | * @task: controlling RPC task |
| @@ -814,27 +808,52 @@ int rpcauth_wrap_req(struct rpc_task *task, struct xdr_stream *xdr) · 27 unmodified lines | ||
| 814 | 808 | return ops->crwrap_req(task, xdr); |
| 815 | 809 | } |
| 816 | 810 | |
| 817 | −static int | |
| 818 | −rpcauth_unwrap_req_decode(kxdrdproc_t decode, struct rpc_rqst *rqstp, | |
| 819 | − __be32 *data, void *obj) | |
| 811 | +/** | |
| 812 | + * rpcauth_checkverf - Validate verifier in RPC Reply header | |
| 813 | + * @task: controlling RPC task | |
| 814 | + * @xdr: xdr_stream containing RPC Reply header | |
| 815 | + * | |
| 816 | + * On success, @xdr is updated to point past the verifier and | |
| 817 | + * zero is returned. Otherwise, @xdr is in an undefined state | |
| 818 | + * and a negative errno is returned. | |
| 819 | + */ | |
| 820 | +int | |
| 821 | +rpcauth_checkverf(struct rpc_task *task, struct xdr_stream *xdr) | |
| 820 | 822 | { |
| 821 | − struct xdr_stream xdr; | |
| 823 | + const struct rpc_credops *ops = task->tk_rqstp->rq_cred->cr_ops; | |
| 822 | 824 | |
| 823 | − xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, data, rqstp); | |
| 824 | − return decode(rqstp, &xdr, obj); | |
| 825 | + return ops->crvalidate(task, xdr); | |
| 825 | 826 | } |
| 826 | 827 | |
| 828 | +/** | |
| 829 | + * rpcauth_unwrap_resp_decode - Invoke XDR decode function | |
| 830 | + * @task: controlling RPC task | |
| 831 | + * @xdr: stream where the Reply message resides | |
| 832 | + * | |
| 833 | + * Returns zero on success; otherwise a negative errno is returned. | |
| 834 | + */ | |
| 827 | 835 | int |
| 828 | −rpcauth_unwrap_resp(struct rpc_task *task, kxdrdproc_t decode, void *rqstp, | |
| 829 | − __be32 *data, void *obj) | |
| 836 | +rpcauth_unwrap_resp_decode(struct rpc_task *task, struct xdr_stream *xdr) | |
| 830 | 837 | { |
| 831 | − struct rpc_cred *cred = task->tk_rqstp->rq_cred; | |
| 838 | + kxdrdproc_t decode = task->tk_msg.rpc_proc->p_decode; | |
| 839 | + | |
| 840 | + return decode(task->tk_rqstp, xdr, task->tk_msg.rpc_resp); | |
| 841 | +} | |
| 842 | +EXPORT_SYMBOL_GPL(rpcauth_unwrap_resp_decode); | |
| 843 | + | |
| 844 | +/** | |
| 845 | + * rpcauth_unwrap_resp - Invoke unwrap and decode function for the cred | |
| 846 | + * @task: controlling RPC task | |
| 847 | + * @xdr: stream where the Reply message resides | |
| 848 | + * | |
| 849 | + * Returns zero on success; otherwise a negative errno is returned. | |
| 850 | + */ | |
| 851 | +int | |
| 852 | +rpcauth_unwrap_resp(struct rpc_task *task, struct xdr_stream *xdr) | |
| 853 | +{ | |
| 854 | + const struct rpc_credops *ops = task->tk_rqstp->rq_cred->cr_ops; | |
| 832 | 855 | |
| 833 | − if (cred->cr_ops->crunwrap_resp) | |
| 834 | − return cred->cr_ops->crunwrap_resp(task, decode, rqstp, | |
| 835 | − data, obj); | |
| 836 | − /* By default, we decode the arguments normally. */ | |
| 837 | − return rpcauth_unwrap_req_decode(decode, rqstp, data, obj); | |
| 856 | + return ops->crunwrap_resp(task, xdr); | |
| 838 | 857 | } |
| 839 | 858 | |
| 840 | 859 | bool |
| @@ -1671,59 +1671,62 @@ gss_refresh_null(struct rpc_task *task) · 1670 unmodified lines | ||
| 1671 | 1671 | return 0; |
| 1672 | 1672 | } |
| 1673 | 1673 | |
| 1674 | −static __be32 * | |
| 1675 | −gss_validate(struct rpc_task *task, __be32 *p) | |
| 1674 | +static int | |
| 1675 | +gss_validate(struct rpc_task *task, struct xdr_stream *xdr) | |
| 1676 | 1676 | { |
| 1677 | 1677 | struct rpc_cred *cred = task->tk_rqstp->rq_cred; |
| 1678 | 1678 | struct gss_cl_ctx *ctx = gss_cred_get_ctx(cred); |
| 1679 | − __be32 *seq = NULL; | |
| 1679 | + __be32 *p, *seq = NULL; | |
| 1680 | 1680 | struct kvec iov; |
| 1681 | 1681 | struct xdr_buf verf_buf; |
| 1682 | 1682 | struct xdr_netobj mic; |
| 1683 | − u32 flav,len; | |
| 1684 | − u32 maj_stat; | |
| 1685 | − __be32 *ret = ERR_PTR(-EIO); | |
| 1683 | + u32 len, maj_stat; | |
| 1684 | + int status; | |
| 1686 | 1685 | |
| 1687 | − dprintk("RPC: %5u %s\n", task->tk_pid, __func__); | |
| 1686 | + p = xdr_inline_decode(xdr, 2 * sizeof(*p)); | |
| 1687 | + if (!p) | |
| 1688 | + goto validate_failed; | |
| 1689 | + if (*p++ != rpc_auth_gss) | |
| 1690 | + goto validate_failed; | |
| 1691 | + len = be32_to_cpup(p); | |
| 1692 | + if (len > RPC_MAX_AUTH_SIZE) | |
| 1693 | + goto validate_failed; | |
| 1694 | + p = xdr_inline_decode(xdr, len); | |
| 1695 | + if (!p) | |
| 1696 | + goto validate_failed; | |
| 1688 | 1697 | |
| 1689 | − flav = ntohl(*p++); | |
| 1690 | − if ((len = ntohl(*p++)) > RPC_MAX_AUTH_SIZE) | |
| 1691 | − goto out_bad; | |
| 1692 | − if (flav != RPC_AUTH_GSS) | |
| 1693 | − goto out_bad; | |
| 1694 | 1698 | seq = kmalloc(4, GFP_NOFS); |
| 1695 | 1699 | if (!seq) |
| 1696 | − goto out_bad; | |
| 1697 | − *seq = htonl(task->tk_rqstp->rq_seqno); | |
| 1700 | + goto validate_failed; | |
| 1701 | + *seq = cpu_to_be32(task->tk_rqstp->rq_seqno); | |
| 1698 | 1702 | iov.iov_base = seq; |
| 1699 | 1703 | iov.iov_len = 4; |
| 1700 | 1704 | xdr_buf_from_iov(&iov, &verf_buf); |
| 1701 | 1705 | mic.data = (u8 *)p; |
| 1702 | 1706 | mic.len = len; |
| 1703 | − | |
| 1704 | − ret = ERR_PTR(-EACCES); | |
| 1705 | 1707 | maj_stat = gss_verify_mic(ctx->gc_gss_ctx, &verf_buf, &mic); |
| 1706 | 1708 | if (maj_stat == GSS_S_CONTEXT_EXPIRED) |
| 1707 | 1709 | clear_bit(RPCAUTH_CRED_UPTODATE, &cred->cr_flags); |
| 1708 | − if (maj_stat) { | |
| 1709 | − dprintk("RPC: %5u %s: gss_verify_mic returned error 0x%08x\n", | |
| 1710 | − task->tk_pid, __func__, maj_stat); | |
| 1711 | − goto out_bad; | |
| 1712 | − } | |
| 1710 | + if (maj_stat) | |
| 1711 | + goto bad_mic; | |
| 1712 | + | |
| 1713 | 1713 | /* We leave it to unwrap to calculate au_rslack. For now we just |
| 1714 | 1714 | * calculate the length of the verifier: */ |
| 1715 | 1715 | cred->cr_auth->au_verfsize = XDR_QUADLEN(len) + 2; |
| 1716 | + status = 0; | |
| 1717 | +out: | |
| 1716 | 1718 | gss_put_ctx(ctx); |
| 1717 | − dprintk("RPC: %5u %s: gss_verify_mic succeeded.\n", | |
| 1718 | − task->tk_pid, __func__); | |
| 1719 | − kfree(seq); | |
| 1720 | − return p + XDR_QUADLEN(len); | |
| 1721 | −out_bad: | |
| 1722 | − gss_put_ctx(ctx); | |
| 1723 | − dprintk("RPC: %5u %s failed ret %ld.\n", task->tk_pid, __func__, | |
| 1724 | − PTR_ERR(ret)); | |
| 1725 | 1719 | kfree(seq); |
| 1726 | − return ret; | |
| 1720 | + return status; | |
| 1721 | + | |
| 1722 | +validate_failed: | |
| 1723 | + status = -EIO; | |
| 1724 | + goto out; | |
| 1725 | +bad_mic: | |
| 1726 | + dprintk("RPC: %5u %s: gss_verify_mic returned error 0x%08x\n", | |
| 1727 | + task->tk_pid, __func__, maj_stat); | |
| 1728 | + status = -EACCES; | |
| 1729 | + goto out; | |
| 1727 | 1730 | } |
| 1728 | 1731 | |
| 1729 | 1732 | static int gss_wrap_req_integ(struct rpc_cred *cred, struct gss_cl_ctx *ctx, |
| @@ -1921,79 +1924,98 @@ out: · 191 unmodified lines | ||
| 1921 | 1924 | return status; |
| 1922 | 1925 | } |
| 1923 | 1926 | |
| 1924 | −static inline int | |
| 1927 | +static int | |
| 1928 | +gss_unwrap_resp_auth(struct rpc_cred *cred) | |
| 1929 | +{ | |
| 1930 | + cred->cr_auth->au_rslack = cred->cr_auth->au_verfsize; | |
| 1931 | + return 0; | |
| 1932 | +} | |
| 1933 | + | |
| 1934 | +static int | |
| 1925 | 1935 | gss_unwrap_resp_integ(struct rpc_cred *cred, struct gss_cl_ctx *ctx, |
| 1926 | − struct rpc_rqst *rqstp, __be32 **p) | |
| 1936 | + struct rpc_rqst *rqstp, struct xdr_stream *xdr) | |
| 1927 | 1937 | { |
| 1928 | − struct xdr_buf *rcv_buf = &rqstp->rq_rcv_buf; | |
| 1929 | − struct xdr_buf integ_buf; | |
| 1938 | + struct xdr_buf integ_buf, *rcv_buf = &rqstp->rq_rcv_buf; | |
| 1939 | + u32 data_offset, mic_offset, integ_len, maj_stat; | |
| 1930 | 1940 | struct xdr_netobj mic; |
| 1931 | − u32 data_offset, mic_offset; | |
| 1932 | − u32 integ_len; | |
| 1933 | − u32 maj_stat; | |
| 1934 | − int status = -EIO; | |
| 1941 | + __be32 *p; | |
| 1935 | 1942 | |
| 1936 | − integ_len = ntohl(*(*p)++); | |
| 1943 | + p = xdr_inline_decode(xdr, 2 * sizeof(*p)); | |
| 1944 | + if (unlikely(!p)) | |
| 1945 | + goto unwrap_failed; | |
| 1946 | + integ_len = be32_to_cpup(p++); | |
| 1937 | 1947 | if (integ_len & 3) |
| 1938 | − return status; | |
| 1939 | − data_offset = (u8 *)(*p) - (u8 *)rcv_buf->head[0].iov_base; | |
| 1948 | + goto unwrap_failed; | |
| 1949 | + data_offset = (u8 *)(p) - (u8 *)rcv_buf->head[0].iov_base; | |
| 1940 | 1950 | mic_offset = integ_len + data_offset; |
| 1941 | 1951 | if (mic_offset > rcv_buf->len) |
| 1942 | − return status; | |
| 1943 | − if (ntohl(*(*p)++) != rqstp->rq_seqno) | |
| 1944 | − return status; | |
| 1945 | − | |
| 1946 | − if (xdr_buf_subsegment(rcv_buf, &integ_buf, data_offset, | |
| 1947 | − mic_offset - data_offset)) | |
| 1948 | − return status; | |
| 1952 | + goto unwrap_failed; | |
| 1953 | + if (be32_to_cpup(p) != rqstp->rq_seqno) | |
| 1954 | + goto unwrap_failed; | |
| 1949 | 1955 | |
| 1956 | + if (xdr_buf_subsegment(rcv_buf, &integ_buf, data_offset, integ_len)) | |
| 1957 | + goto unwrap_failed; | |
| 1950 | 1958 | if (xdr_buf_read_netobj(rcv_buf, &mic, mic_offset)) |
| 1951 | − return status; | |
| 1952 | − | |
| 1959 | + goto unwrap_failed; | |
| 1953 | 1960 | maj_stat = gss_verify_mic(ctx->gc_gss_ctx, &integ_buf, &mic); |
| 1954 | 1961 | if (maj_stat == GSS_S_CONTEXT_EXPIRED) |
| 1955 | 1962 | clear_bit(RPCAUTH_CRED_UPTODATE, &cred->cr_flags); |
| 1956 | 1963 | if (maj_stat != GSS_S_COMPLETE) |
| 1957 | − return status; | |
| 1964 | + goto bad_mic; | |
| 1965 | + | |
| 1966 | + cred->cr_auth->au_rslack = cred->cr_auth->au_verfsize + 2 + | |
| 1967 | + 1 + XDR_QUADLEN(mic.len); | |
| 1958 | 1968 | return 0; |
| 1969 | +unwrap_failed: | |
| 1970 | + return -EIO; | |
| 1971 | +bad_mic: | |
| 1972 | + dprintk("RPC: %s: gss_verify_mic returned error 0x%08x\n", | |
| 1973 | + __func__, maj_stat); | |
| 1974 | + return -EIO; | |
| 1959 | 1975 | } |
| 1960 | 1976 | |
| 1961 | −static inline int | |
| 1977 | +static int | |
| 1962 | 1978 | gss_unwrap_resp_priv(struct rpc_cred *cred, struct gss_cl_ctx *ctx, |
| 1963 | − struct rpc_rqst *rqstp, __be32 **p) | |
| 1964 | −{ | |
| 1965 | − struct xdr_buf *rcv_buf = &rqstp->rq_rcv_buf; | |
| 1966 | − u32 offset; | |
| 1967 | − u32 opaque_len; | |
| 1968 | − u32 maj_stat; | |
| 1969 | − int status = -EIO; | |
| 1970 | − | |
| 1971 | − opaque_len = ntohl(*(*p)++); | |
| 1972 | − offset = (u8 *)(*p) - (u8 *)rcv_buf->head[0].iov_base; | |
| 1979 | + struct rpc_rqst *rqstp, struct xdr_stream *xdr) | |
| 1980 | +{ | |
| 1981 | + struct xdr_buf *rcv_buf = &rqstp->rq_rcv_buf; | |
| 1982 | + struct kvec *head = rqstp->rq_rcv_buf.head; | |
| 1983 | + unsigned int savedlen = rcv_buf->len; | |
| 1984 | + u32 offset, opaque_len, maj_stat; | |
| 1985 | + __be32 *p; | |
| 1986 | + | |
| 1987 | + p = xdr_inline_decode(xdr, 2 * sizeof(*p)); | |
| 1988 | + if (unlikely(!p)) | |
| 1989 | + goto unwrap_failed; | |
| 1990 | + opaque_len = be32_to_cpup(p++); | |
| 1991 | + offset = (u8 *)(p) - (u8 *)head->iov_base; | |
| 1973 | 1992 | if (offset + opaque_len > rcv_buf->len) |
| 1974 | − return status; | |
| 1975 | − /* remove padding: */ | |
| 1993 | + goto unwrap_failed; | |
| 1976 | 1994 | rcv_buf->len = offset + opaque_len; |
| 1977 | 1995 | |
| 1978 | 1996 | maj_stat = gss_unwrap(ctx->gc_gss_ctx, offset, rcv_buf); |
| 1979 | 1997 | if (maj_stat == GSS_S_CONTEXT_EXPIRED) |
| 1980 | 1998 | clear_bit(RPCAUTH_CRED_UPTODATE, &cred->cr_flags); |
| 1981 | 1999 | if (maj_stat != GSS_S_COMPLETE) |
| 1982 | − return status; | |
| 1983 | − if (ntohl(*(*p)++) != rqstp->rq_seqno) | |
| 1984 | − return status; | |
| 1985 | − | |
| 1986 | − return 0; | |
| 1987 | −} | |
| 2000 | + goto bad_unwrap; | |
| 2001 | + /* gss_unwrap decrypted the sequence number */ | |
| 2002 | + if (be32_to_cpup(p++) != rqstp->rq_seqno) | |
| 2003 | + goto unwrap_failed; | |
| 1988 | 2004 | |
| 1989 | −static int | |
| 1990 | −gss_unwrap_req_decode(kxdrdproc_t decode, struct rpc_rqst *rqstp, | |
| 1991 | − __be32 *p, void *obj) | |
| 1992 | −{ | |
| 1993 | − struct xdr_stream xdr; | |
| 2005 | + /* gss_unwrap redacts the opaque blob from the head iovec. | |
| 2006 | + * rcv_buf has changed, thus the stream needs to be reset. | |
| 2007 | + */ | |
| 2008 | + xdr_init_decode(xdr, rcv_buf, p, rqstp); | |
| 1994 | 2009 | |
| 1995 | − xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p, rqstp); | |
| 1996 | − return decode(rqstp, &xdr, obj); | |
| 2010 | + cred->cr_auth->au_rslack = cred->cr_auth->au_verfsize + 2 + | |
| 2011 | + XDR_QUADLEN(savedlen - rcv_buf->len); | |
| 2012 | + return 0; | |
| 2013 | +unwrap_failed: | |
| 2014 | + return -EIO; | |
| 2015 | +bad_unwrap: | |
| 2016 | + dprintk("RPC: %s: gss_unwrap returned error 0x%08x\n", | |
| 2017 | + __func__, maj_stat); | |
| 2018 | + return -EIO; | |
| 1997 | 2019 | } |
| 1998 | 2020 | |
| 1999 | 2021 | static bool |
| @@ -2037,39 +2059,33 @@ out: · 37 unmodified lines | ||
| 2037 | 2059 | } |
| 2038 | 2060 | |
| 2039 | 2061 | static int |
| 2040 | −gss_unwrap_resp(struct rpc_task *task, | |
| 2041 | − kxdrdproc_t decode, void *rqstp, __be32 *p, void *obj) | |
| 2062 | +gss_unwrap_resp(struct rpc_task *task, struct xdr_stream *xdr) | |
| 2042 | 2063 | { |
| 2043 | − struct rpc_cred *cred = task->tk_rqstp->rq_cred; | |
| 2064 | + struct rpc_rqst *rqstp = task->tk_rqstp; | |
| 2065 | + struct rpc_cred *cred = rqstp->rq_cred; | |
| 2044 | 2066 | struct gss_cred *gss_cred = container_of(cred, struct gss_cred, |
| 2045 | 2067 | gc_base); |
| 2046 | 2068 | struct gss_cl_ctx *ctx = gss_cred_get_ctx(cred); |
| 2047 | − __be32 *savedp = p; | |
| 2048 | − struct kvec *head = ((struct rpc_rqst *)rqstp)->rq_rcv_buf.head; | |
| 2049 | − int savedlen = head->iov_len; | |
| 2050 | − int status = -EIO; | |
| 2069 | + int status = -EIO; | |
| 2051 | 2070 | |
| 2052 | 2071 | if (ctx->gc_proc != RPC_GSS_PROC_DATA) |
| 2053 | 2072 | goto out_decode; |
| 2054 | 2073 | switch (gss_cred->gc_service) { |
| 2055 | 2074 | case RPC_GSS_SVC_NONE: |
| 2075 | + status = gss_unwrap_resp_auth(cred); | |
| 2056 | 2076 | break; |
| 2057 | 2077 | case RPC_GSS_SVC_INTEGRITY: |
| 2058 | − status = gss_unwrap_resp_integ(cred, ctx, rqstp, &p); | |
| 2059 | − if (status) | |
| 2060 | − goto out; | |
| 2078 | + status = gss_unwrap_resp_integ(cred, ctx, rqstp, xdr); | |
| 2061 | 2079 | break; |
| 2062 | 2080 | case RPC_GSS_SVC_PRIVACY: |
| 2063 | − status = gss_unwrap_resp_priv(cred, ctx, rqstp, &p); | |
| 2064 | − if (status) | |
| 2065 | − goto out; | |
| 2081 | + status = gss_unwrap_resp_priv(cred, ctx, rqstp, xdr); | |
| 2066 | 2082 | break; |
| 2067 | 2083 | } |
| 2068 | − /* take into account extra slack for integrity and privacy cases: */ | |
| 2069 | − cred->cr_auth->au_rslack = cred->cr_auth->au_verfsize + (p - savedp) | |
| 2070 | − + (savedlen - head->iov_len); | |
| 2084 | + if (status) | |
| 2085 | + goto out; | |
| 2086 | + | |
| 2071 | 2087 | out_decode: |
| 2072 | − status = gss_unwrap_req_decode(decode, rqstp, p, obj); | |
| 2088 | + status = rpcauth_unwrap_resp_decode(task, xdr); | |
| 2073 | 2089 | out: |
| 2074 | 2090 | gss_put_ctx(ctx); |
| 2075 | 2091 | dprintk("RPC: %5u %s returning %d\n", |
| @@ -86,25 +86,19 @@ nul_refresh(struct rpc_task *task) · 85 unmodified lines | ||
| 86 | 86 | return 0; |
| 87 | 87 | } |
| 88 | 88 | |
| 89 | −static __be32 * | |
| 90 | −nul_validate(struct rpc_task *task, __be32 *p) | |
| 89 | +static int | |
| 90 | +nul_validate(struct rpc_task *task, struct xdr_stream *xdr) | |
| 91 | 91 | { |
| 92 | − rpc_authflavor_t flavor; | |
| 93 | − u32 size; | |
| 94 | − | |
| 95 | − flavor = ntohl(*p++); | |
| 96 | − if (flavor != RPC_AUTH_NULL) { | |
| 97 | − printk("RPC: bad verf flavor: %u\n", flavor); | |
| 98 | − return ERR_PTR(-EIO); | |
| 99 | − } | |
| 100 | − | |
| 101 | − size = ntohl(*p++); | |
| 102 | − if (size != 0) { | |
| 103 | − printk("RPC: bad verf size: %u\n", size); | |
| 104 | − return ERR_PTR(-EIO); | |
| 105 | − } | |
| 106 | − | |
| 107 | − return p; | |
| 92 | + __be32 *p; | |
| 93 | + | |
| 94 | + p = xdr_inline_decode(xdr, 2 * sizeof(*p)); | |
| 95 | + if (!p) | |
| 96 | + return -EIO; | |
| 97 | + if (*p++ != rpc_auth_null) | |
| 98 | + return -EIO; | |
| 99 | + if (*p != xdr_zero) | |
| 100 | + return -EIO; | |
| 101 | + return 0; | |
| 108 | 102 | } |
| 109 | 103 | |
| 110 | 104 | const struct rpc_authops authnull_ops = { |
| @@ -134,6 +128,7 @@ const struct rpc_credops null_credops = { · 23 unmodified lines | ||
| 134 | 128 | .crwrap_req = rpcauth_wrap_req_encode, |
| 135 | 129 | .crrefresh = nul_refresh, |
| 136 | 130 | .crvalidate = nul_validate, |
| 131 | + .crunwrap_resp = rpcauth_unwrap_resp_decode, | |
| 137 | 132 | }; |
| 138 | 133 | |
| 139 | 134 | static |
| @@ -160,29 +160,32 @@ unx_refresh(struct rpc_task *task) · 159 unmodified lines | ||
| 160 | 160 | return 0; |
| 161 | 161 | } |
| 162 | 162 | |
| 163 | −static __be32 * | |
| 164 | −unx_validate(struct rpc_task *task, __be32 *p) | |
| 163 | +static int | |
| 164 | +unx_validate(struct rpc_task *task, struct xdr_stream *xdr) | |
| 165 | 165 | { |
| 166 | − rpc_authflavor_t flavor; | |
| 167 | − u32 size; | |
| 168 | − | |
| 169 | − flavor = ntohl(*p++); | |
| 170 | − if (flavor != RPC_AUTH_NULL && | |
| 171 | − flavor != RPC_AUTH_UNIX && | |
| 172 | − flavor != RPC_AUTH_SHORT) { | |
| 173 | − printk("RPC: bad verf flavor: %u\n", flavor); | |
| 174 | − return ERR_PTR(-EIO); | |
| 175 | − } | |
| 166 | + __be32 *p; | |
| 167 | + u32 size; | |
| 176 | 168 | |
| 177 | − size = ntohl(*p++); | |
| 178 | − if (size > RPC_MAX_AUTH_SIZE) { | |
| 179 | − printk("RPC: giant verf size: %u\n", size); | |
| 180 | − return ERR_PTR(-EIO); | |
| 169 | + p = xdr_inline_decode(xdr, 2 * sizeof(*p)); | |
| 170 | + if (!p) | |
| 171 | + return -EIO; | |
| 172 | + switch (*p++) { | |
| 173 | + case rpc_auth_null: | |
| 174 | + case rpc_auth_unix: | |
| 175 | + case rpc_auth_short: | |
| 176 | + break; | |
| 177 | + default: | |
| 178 | + return -EIO; | |
| 181 | 179 | } |
| 182 | − task->tk_rqstp->rq_cred->cr_auth->au_rslack = (size >> 2) + 2; | |
| 183 | − p += (size >> 2); | |
| 180 | + size = be32_to_cpup(p); | |
| 181 | + if (size > RPC_MAX_AUTH_SIZE) | |
| 182 | + return -EIO; | |
| 183 | + p = xdr_inline_decode(xdr, size); | |
| 184 | + if (!p) | |
| 185 | + return -EIO; | |
| 184 | 186 | |
| 185 | − return p; | |
| 187 | + task->tk_rqstp->rq_cred->cr_auth->au_rslack = (size >> 2) + 2; | |
| 188 | + return 0; | |
| 186 | 189 | } |
| 187 | 190 | |
| 188 | 191 | int __init rpc_init_authunix(void) |
| @@ -223,4 +226,5 @@ const struct rpc_credops unix_credops = { · 34 unmodified lines | ||
| 223 | 226 | .crwrap_req = rpcauth_wrap_req_encode, |
| 224 | 227 | .crrefresh = unx_refresh, |
| 225 | 228 | .crvalidate = unx_validate, |
| 229 | + .crunwrap_resp = rpcauth_unwrap_resp_decode, | |
| 226 | 230 | }; |
| @@ -79,7 +79,8 @@ static void call_connect_status(struct rpc_task *task); · 78 unmodified lines | ||
| 79 | 79 | |
| 80 | 80 | static int rpc_encode_header(struct rpc_task *task, |
| 81 | 81 | struct xdr_stream *xdr); |
| 82 | −static __be32 *rpc_decode_header(struct rpc_task *task); | |
| 82 | +static int rpc_decode_header(struct rpc_task *task, | |
| 83 | + struct xdr_stream *xdr); | |
| 83 | 84 | static int rpc_ping(struct rpc_clnt *clnt); |
| 84 | 85 | |
| 85 | 86 | static void rpc_register_client(struct rpc_clnt *clnt) |
| @@ -2251,12 +2252,11 @@ call_decode(struct rpc_task *task) · 2165 unmodified lines | ||
| 2251 | 2252 | { |
| 2252 | 2253 | struct rpc_clnt *clnt = task->tk_client; |
| 2253 | 2254 | struct rpc_rqst *req = task->tk_rqstp; |
| 2254 | − kxdrdproc_t decode = task->tk_msg.rpc_proc->p_decode; | |
| 2255 | − __be32 *p; | |
| 2255 | + struct xdr_stream xdr; | |
| 2256 | 2256 | |
| 2257 | 2257 | dprint_status(task); |
| 2258 | 2258 | |
| 2259 | − if (!decode) { | |
| 2259 | + if (!task->tk_msg.rpc_proc->p_decode) { | |
| 2260 | 2260 | task->tk_action = rpc_exit_task; |
| 2261 | 2261 | return; |
| 2262 | 2262 | } |
| @@ -2292,29 +2292,27 @@ call_decode(struct rpc_task *task) · 29 unmodified lines | ||
| 2292 | 2292 | goto out_retry; |
| 2293 | 2293 | } |
| 2294 | 2294 | |
| 2295 | − p = rpc_decode_header(task); | |
| 2296 | − if (IS_ERR(p)) { | |
| 2297 | − if (p == ERR_PTR(-EAGAIN)) | |
| 2298 | − goto out_retry; | |
| 2295 | + xdr_init_decode(&xdr, &req->rq_rcv_buf, | |
| 2296 | + req->rq_rcv_buf.head[0].iov_base, req); | |
| 2297 | + switch (rpc_decode_header(task, &xdr)) { | |
| 2298 | + case 0: | |
| 2299 | + task->tk_action = rpc_exit_task; | |
| 2300 | + task->tk_status = rpcauth_unwrap_resp(task, &xdr); | |
| 2301 | + dprintk("RPC: %5u %s result %d\n", | |
| 2302 | + task->tk_pid, __func__, task->tk_status); | |
| 2299 | 2303 | return; |
| 2300 | − } | |
| 2301 | − task->tk_action = rpc_exit_task; | |
| 2302 | − | |
| 2303 | − task->tk_status = rpcauth_unwrap_resp(task, decode, req, p, | |
| 2304 | − task->tk_msg.rpc_resp); | |
| 2305 | − | |
| 2306 | − dprintk("RPC: %5u call_decode result %d\n", task->tk_pid, | |
| 2307 | − task->tk_status); | |
| 2308 | − return; | |
| 2304 | + case -EAGAIN: | |
| 2309 | 2305 | out_retry: |
| 2310 | − task->tk_status = 0; | |
| 2311 | − /* Note: rpc_decode_header() may have freed the RPC slot */ | |
| 2312 | − if (task->tk_rqstp == req) { | |
| 2313 | − xdr_free_bvec(&req->rq_rcv_buf); | |
| 2314 | − req->rq_reply_bytes_recvd = req->rq_rcv_buf.len = 0; | |
| 2315 | − if (task->tk_client->cl_discrtry) | |
| 2316 | − xprt_conditional_disconnect(req->rq_xprt, | |
| 2317 | − req->rq_connect_cookie); | |
| 2306 | + task->tk_status = 0; | |
| 2307 | + /* Note: rpc_decode_header() may have freed the RPC slot */ | |
| 2308 | + if (task->tk_rqstp == req) { | |
| 2309 | + xdr_free_bvec(&req->rq_rcv_buf); | |
| 2310 | + req->rq_reply_bytes_recvd = 0; | |
| 2311 | + req->rq_rcv_buf.len = 0; | |
| 2312 | + if (task->tk_client->cl_discrtry) | |
| 2313 | + xprt_conditional_disconnect(req->rq_xprt, | |
| 2314 | + req->rq_connect_cookie); | |
| 2315 | + } | |
| 2318 | 2316 | } |
| 2319 | 2317 | } |
| 2320 | 2318 | |
| @@ -2347,14 +2345,12 @@ out_fail: · 26 unmodified lines | ||
| 2347 | 2345 | return error; |
| 2348 | 2346 | } |
| 2349 | 2347 | |
| 2350 | −static noinline __be32 * | |
| 2351 | −rpc_decode_header(struct rpc_task *task) | |
| 2348 | +static noinline int | |
| 2349 | +rpc_decode_header(struct rpc_task *task, struct xdr_stream *xdr) | |
| 2352 | 2350 | { |
| 2353 | 2351 | struct rpc_clnt *clnt = task->tk_client; |
| 2354 | − struct kvec *iov = &task->tk_rqstp->rq_rcv_buf.head[0]; | |
| 2355 | − int len = task->tk_rqstp->rq_rcv_buf.len >> 2; | |
| 2356 | − __be32 *p = iov->iov_base; | |
| 2357 | 2352 | int error = -EACCES; |
| 2353 | + __be32 *p; | |
| 2358 | 2354 | |
| 2359 | 2355 | /* RFC-1014 says that the representation of XDR data must be a |
| 2360 | 2356 | * multiple of four bytes |
| @@ -2363,25 +2359,26 @@ rpc_decode_header(struct rpc_task *task) · 2 unmodified lines | ||
| 2363 | 2359 | */ |
| 2364 | 2360 | if (task->tk_rqstp->rq_rcv_buf.len & 3) |
| 2365 | 2361 | goto out_badlen; |
| 2366 | − if ((len -= 3) < 0) | |
| 2367 | − goto out_unparsable; | |
| 2368 | 2362 | |
| 2363 | + p = xdr_inline_decode(xdr, 3 * sizeof(*p)); | |
| 2364 | + if (!p) | |
| 2365 | + goto out_unparsable; | |
| 2369 | 2366 | p++; /* skip XID */ |
| 2370 | 2367 | if (*p++ != rpc_reply) |
| 2371 | 2368 | goto out_unparsable; |
| 2372 | 2369 | if (*p++ != rpc_msg_accepted) |
| 2373 | 2370 | goto out_msg_denied; |
| 2374 | 2371 | |
| 2375 | − p = rpcauth_checkverf(task, p); | |
| 2376 | − if (IS_ERR(p)) | |
| 2372 | + error = rpcauth_checkverf(task, xdr); | |
| 2373 | + if (error) | |
| 2377 | 2374 | goto out_verifier; |
| 2378 | 2375 | |
| 2379 | − len = p - (__be32 *)iov->iov_base - 1; | |
| 2380 | − if (len < 0) | |
| 2376 | + p = xdr_inline_decode(xdr, sizeof(*p)); | |
| 2377 | + if (!p) | |
| 2381 | 2378 | goto out_unparsable; |
| 2382 | − switch (*p++) { | |
| 2379 | + switch (*p) { | |
| 2383 | 2380 | case rpc_success: |
| 2384 | − return p; | |
| 2381 | + return 0; | |
| 2385 | 2382 | case rpc_prog_unavail: |
| 2386 | 2383 | trace_rpc__prog_unavail(task); |
| 2387 | 2384 | error = -EPFNOSUPPORT; |
| @@ -2406,11 +2403,11 @@ out_garbage: · 18 unmodified lines | ||
| 2406 | 2403 | if (task->tk_garb_retry) { |
| 2407 | 2404 | task->tk_garb_retry--; |
| 2408 | 2405 | task->tk_action = call_encode; |
| 2409 | − return ERR_PTR(-EAGAIN); | |
| 2406 | + return -EAGAIN; | |
| 2410 | 2407 | } |
| 2411 | 2408 | out_err: |
| 2412 | 2409 | rpc_exit(task, error); |
| 2413 | − return ERR_PTR(error); | |
| 2410 | + return error; | |
| 2414 | 2411 | |
| 2415 | 2412 | out_badlen: |
| 2416 | 2413 | trace_rpc__unparsable(task); |
| @@ -2424,10 +2421,12 @@ out_unparsable: · 7 unmodified lines | ||
| 2424 | 2421 | |
| 2425 | 2422 | out_verifier: |
| 2426 | 2423 | trace_rpc_bad_verifier(task); |
| 2427 | − error = PTR_ERR(p); | |
| 2428 | 2424 | goto out_garbage; |
| 2429 | 2425 | |
| 2430 | 2426 | out_msg_denied: |
| 2427 | + p = xdr_inline_decode(xdr, sizeof(*p)); | |
| 2428 | + if (!p) | |
| 2429 | + goto out_unparsable; | |
| 2431 | 2430 | switch (*p++) { |
| 2432 | 2431 | case rpc_auth_error: |
| 2433 | 2432 | break; |
| @@ -2441,6 +2440,9 @@ out_msg_denied: · 7 unmodified lines | ||
| 2441 | 2440 | goto out_err; |
| 2442 | 2441 | } |
| 2443 | 2442 | |
| 2443 | + p = xdr_inline_decode(xdr, sizeof(*p)); | |
| 2444 | + if (!p) | |
| 2445 | + goto out_unparsable; | |
| 2444 | 2446 | switch (*p++) { |
| 2445 | 2447 | case rpc_autherr_rejectedcred: |
| 2446 | 2448 | case rpc_autherr_rejectedverf: |
| @@ -2454,7 +2456,7 @@ out_msg_denied: · 7 unmodified lines | ||
| 2454 | 2456 | /* Ensure we obtain a new XID! */ |
| 2455 | 2457 | xprt_release(task); |
| 2456 | 2458 | task->tk_action = call_reserve; |
| 2457 | − return ERR_PTR(-EAGAIN); | |
| 2459 | + return -EAGAIN; | |
| 2458 | 2460 | case rpc_autherr_badcred: |
| 2459 | 2461 | case rpc_autherr_badverf: |
| 2460 | 2462 | /* possibly garbled cred/verf? */ |
| @@ -2463,7 +2465,7 @@ out_msg_denied: · 2 unmodified lines | ||
| 2463 | 2465 | task->tk_garb_retry--; |
| 2464 | 2466 | trace_rpc__bad_creds(task); |
| 2465 | 2467 | task->tk_action = call_encode; |
| 2466 | − return ERR_PTR(-EAGAIN); | |
| 2468 | + return -EAGAIN; | |
| 2467 | 2469 | case rpc_autherr_tooweak: |
| 2468 | 2470 | trace_rpc__auth_tooweak(task); |
| 2469 | 2471 | pr_warn("RPC: server %s requires stronger authentication.\n", |