2 * linux/net/sunrpc/gss_krb5_mech.c
4 * Copyright (c) 2001 The Regents of the University of Michigan.
7 * Andy Adamson <andros@umich.edu>
8 * J. Bruce Fields <bfields@umich.edu>
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions and the following disclaimer.
16 * 2. Redistributions in binary form must reproduce the above copyright
17 * notice, this list of conditions and the following disclaimer in the
18 * documentation and/or other materials provided with the distribution.
19 * 3. Neither the name of the University nor the names of its
20 * contributors may be used to endorse or promote products derived
21 * from this software without specific prior written permission.
23 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
24 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
25 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
26 * DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
27 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
28 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
29 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
30 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
31 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
32 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
33 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
37 #include <linux/module.h>
38 #include <linux/init.h>
39 #include <linux/types.h>
40 #include <linux/slab.h>
41 #include <linux/sunrpc/auth.h>
42 #include <linux/sunrpc/gss_krb5.h>
43 #include <linux/sunrpc/xdr.h>
44 #include <linux/crypto.h>
47 # define RPCDBG_FACILITY RPCDBG_AUTH
51 simple_get_bytes(const void *p
, const void *end
, void *res
, int len
)
53 const void *q
= (const void *)((const char *)p
+ len
);
54 if (unlikely(q
> end
|| q
< p
))
55 return ERR_PTR(-EFAULT
);
61 simple_get_netobj(const void *p
, const void *end
, struct xdr_netobj
*res
)
66 p
= simple_get_bytes(p
, end
, &len
, sizeof(len
));
69 q
= (const void *)((const char *)p
+ len
);
70 if (unlikely(q
> end
|| q
< p
))
71 return ERR_PTR(-EFAULT
);
72 res
->data
= kmalloc(len
, GFP_KERNEL
);
73 if (unlikely(res
->data
== NULL
))
74 return ERR_PTR(-ENOMEM
);
75 memcpy(res
->data
, p
, len
);
80 static inline const void *
81 get_key(const void *p
, const void *end
, struct crypto_tfm
**res
)
83 struct xdr_netobj key
;
87 p
= simple_get_bytes(p
, end
, &alg
, sizeof(alg
));
90 p
= simple_get_netobj(p
, end
, &key
);
95 case ENCTYPE_DES_CBC_RAW
:
97 alg_mode
= CRYPTO_TFM_MODE_CBC
;
100 printk("gss_kerberos_mech: unsupported algorithm %d\n", alg
);
101 goto out_err_free_key
;
103 if (!(*res
= crypto_alloc_tfm(alg_name
, alg_mode
))) {
104 printk("gss_kerberos_mech: unable to initialize crypto algorithm %s\n", alg_name
);
105 goto out_err_free_key
;
107 if (crypto_cipher_setkey(*res
, key
.data
, key
.len
)) {
108 printk("gss_kerberos_mech: error setting key for crypto algorithm %s\n", alg_name
);
109 goto out_err_free_tfm
;
116 crypto_free_tfm(*res
);
119 p
= ERR_PTR(-EINVAL
);
125 gss_import_sec_context_kerberos(const void *p
,
127 struct gss_ctx
*ctx_id
)
129 const void *end
= (const void *)((const char *)p
+ len
);
130 struct krb5_ctx
*ctx
;
132 if (!(ctx
= kzalloc(sizeof(*ctx
), GFP_KERNEL
)))
135 p
= simple_get_bytes(p
, end
, &ctx
->initiate
, sizeof(ctx
->initiate
));
137 goto out_err_free_ctx
;
138 p
= simple_get_bytes(p
, end
, &ctx
->seed_init
, sizeof(ctx
->seed_init
));
140 goto out_err_free_ctx
;
141 p
= simple_get_bytes(p
, end
, ctx
->seed
, sizeof(ctx
->seed
));
143 goto out_err_free_ctx
;
144 p
= simple_get_bytes(p
, end
, &ctx
->signalg
, sizeof(ctx
->signalg
));
146 goto out_err_free_ctx
;
147 p
= simple_get_bytes(p
, end
, &ctx
->sealalg
, sizeof(ctx
->sealalg
));
149 goto out_err_free_ctx
;
150 p
= simple_get_bytes(p
, end
, &ctx
->endtime
, sizeof(ctx
->endtime
));
152 goto out_err_free_ctx
;
153 p
= simple_get_bytes(p
, end
, &ctx
->seq_send
, sizeof(ctx
->seq_send
));
155 goto out_err_free_ctx
;
156 p
= simple_get_netobj(p
, end
, &ctx
->mech_used
);
158 goto out_err_free_ctx
;
159 p
= get_key(p
, end
, &ctx
->enc
);
161 goto out_err_free_mech
;
162 p
= get_key(p
, end
, &ctx
->seq
);
164 goto out_err_free_key1
;
166 p
= ERR_PTR(-EFAULT
);
167 goto out_err_free_key2
;
170 ctx_id
->internal_ctx_id
= ctx
;
171 dprintk("RPC: Successfully imported new context.\n");
175 crypto_free_tfm(ctx
->seq
);
177 crypto_free_tfm(ctx
->enc
);
179 kfree(ctx
->mech_used
.data
);
187 gss_delete_sec_context_kerberos(void *internal_ctx
) {
188 struct krb5_ctx
*kctx
= internal_ctx
;
190 crypto_free_tfm(kctx
->seq
);
191 crypto_free_tfm(kctx
->enc
);
192 kfree(kctx
->mech_used
.data
);
196 static struct gss_api_ops gss_kerberos_ops
= {
197 .gss_import_sec_context
= gss_import_sec_context_kerberos
,
198 .gss_get_mic
= gss_get_mic_kerberos
,
199 .gss_verify_mic
= gss_verify_mic_kerberos
,
200 .gss_wrap
= gss_wrap_kerberos
,
201 .gss_unwrap
= gss_unwrap_kerberos
,
202 .gss_delete_sec_context
= gss_delete_sec_context_kerberos
,
205 static struct pf_desc gss_kerberos_pfs
[] = {
207 .pseudoflavor
= RPC_AUTH_GSS_KRB5
,
208 .service
= RPC_GSS_SVC_NONE
,
212 .pseudoflavor
= RPC_AUTH_GSS_KRB5I
,
213 .service
= RPC_GSS_SVC_INTEGRITY
,
217 .pseudoflavor
= RPC_AUTH_GSS_KRB5P
,
218 .service
= RPC_GSS_SVC_PRIVACY
,
223 static struct gss_api_mech gss_kerberos_mech
= {
225 .gm_owner
= THIS_MODULE
,
226 .gm_ops
= &gss_kerberos_ops
,
227 .gm_pf_num
= ARRAY_SIZE(gss_kerberos_pfs
),
228 .gm_pfs
= gss_kerberos_pfs
,
231 static int __init
init_kerberos_module(void)
235 status
= gss_mech_register(&gss_kerberos_mech
);
237 printk("Failed to register kerberos gss mechanism!\n");
241 static void __exit
cleanup_kerberos_module(void)
243 gss_mech_unregister(&gss_kerberos_mech
);
246 MODULE_LICENSE("GPL");
247 module_init(init_kerberos_module
);
248 module_exit(cleanup_kerberos_module
);