1 /* $FreeBSD: src/sys/netinet6/esp_core.c,v 1.23.2.1 2007/12/07 08:45:28 gnn Exp $ */
2 /* $KAME: esp_core.c,v 1.50 2000/11/02 12:27:38 itojun Exp $ */
5 * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
16 * 3. Neither the name of the project nor the names of its contributors
17 * may be used to endorse or promote products derived from this software
18 * without specific prior written permission.
20 * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
21 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23 * ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
24 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
34 #include "opt_inet6.h"
36 #include <sys/param.h>
37 #include <sys/systm.h>
38 #include <sys/malloc.h>
40 #include <sys/domain.h>
41 #include <sys/protosw.h>
42 #include <sys/socket.h>
43 #include <sys/errno.h>
45 #include <sys/syslog.h>
48 #include <net/route.h>
50 #include <netinet/in.h>
51 #include <netinet/in_var.h>
53 #include <netinet/ip6.h>
54 #include <netinet6/ip6_var.h>
55 #include <netinet/icmp6.h>
58 #include <netinet6/ipsec.h>
60 #include <netinet6/ipsec6.h>
62 #include <netinet6/ah.h>
64 #include <netinet6/ah6.h>
66 #include <netinet6/esp.h>
68 #include <netinet6/esp6.h>
70 #include <netinet6/esp_rijndael.h>
71 #include <netinet6/esp_camellia.h>
72 #include <netinet6/esp_aesctr.h>
73 #include <net/pfkeyv2.h>
74 #include <netproto/key/keydb.h>
75 #include <netproto/key/key.h>
77 #include <crypto/des/des.h>
78 #include <crypto/blowfish/blowfish.h>
80 #include <opencrypto/cast.h>
81 #define cast128_key cast_key
82 #define cast128_setkey(key, rawkey, keybytes) \
83 cast_setkey((key), (rawkey), (keybytes))
84 #define cast128_encrypt(key, inblock, outblock) \
85 cast_encrypt((key), (inblock), (outblock))
86 #define cast128_decrypt(key, inblock, outblock) \
87 cast_decrypt((key), (inblock), (outblock))
89 #include <net/net_osdep.h>
91 static int esp_null_mature (struct secasvar *);
92 static int esp_null_decrypt (struct mbuf *, size_t,
93 struct secasvar *, const struct esp_algorithm *, int);
94 static int esp_null_encrypt (struct mbuf *, size_t, size_t,
95 struct secasvar *, const struct esp_algorithm *, int);
96 static int esp_descbc_mature (struct secasvar *);
97 static int esp_descbc_ivlen (const struct esp_algorithm *,
99 static int esp_des_schedule (const struct esp_algorithm *,
101 static size_t esp_des_schedlen (const struct esp_algorithm *);
102 static int esp_des_blockdecrypt (const struct esp_algorithm *,
103 struct secasvar *, u_int8_t *, u_int8_t *);
104 static int esp_des_blockencrypt (const struct esp_algorithm *,
105 struct secasvar *, u_int8_t *, u_int8_t *);
106 static int esp_cbc_mature (struct secasvar *);
107 static int esp_blowfish_schedule (const struct esp_algorithm *,
109 static size_t esp_blowfish_schedlen (const struct esp_algorithm *);
110 static int esp_blowfish_blockdecrypt (const struct esp_algorithm *,
111 struct secasvar *, u_int8_t *, u_int8_t *);
112 static int esp_blowfish_blockencrypt (const struct esp_algorithm *,
113 struct secasvar *, u_int8_t *, u_int8_t *);
114 static int esp_cast128_schedule (const struct esp_algorithm *,
116 static size_t esp_cast128_schedlen (const struct esp_algorithm *);
117 static int esp_cast128_blockdecrypt (const struct esp_algorithm *,
118 struct secasvar *, u_int8_t *, u_int8_t *);
119 static int esp_cast128_blockencrypt (const struct esp_algorithm *,
120 struct secasvar *, u_int8_t *, u_int8_t *);
121 static int esp_3des_schedule (const struct esp_algorithm *,
123 static size_t esp_3des_schedlen (const struct esp_algorithm *);
124 static int esp_3des_blockdecrypt (const struct esp_algorithm *,
125 struct secasvar *, u_int8_t *, u_int8_t *);
126 static int esp_3des_blockencrypt (const struct esp_algorithm *,
127 struct secasvar *, u_int8_t *, u_int8_t *);
128 static int esp_common_ivlen (const struct esp_algorithm *,
130 static int esp_cbc_decrypt (struct mbuf *, size_t,
131 struct secasvar *, const struct esp_algorithm *, int);
132 static int esp_cbc_encrypt (struct mbuf *, size_t, size_t,
133 struct secasvar *, const struct esp_algorithm *, int);
137 static const struct esp_algorithm esp_algorithms[] = {
138 { 8, -1, esp_descbc_mature, 64, 64, esp_des_schedlen,
140 esp_descbc_ivlen, esp_cbc_decrypt,
141 esp_cbc_encrypt, esp_des_schedule,
142 esp_des_blockdecrypt, esp_des_blockencrypt, },
143 { 8, 8, esp_cbc_mature, 192, 192, esp_3des_schedlen,
145 esp_common_ivlen, esp_cbc_decrypt,
146 esp_cbc_encrypt, esp_3des_schedule,
147 esp_3des_blockdecrypt, esp_3des_blockencrypt, },
148 { 1, 0, esp_null_mature, 0, 2048, NULL, "null",
149 esp_common_ivlen, esp_null_decrypt,
150 esp_null_encrypt, NULL, },
151 { 8, 8, esp_cbc_mature, 40, 448, esp_blowfish_schedlen, "blowfish-cbc",
152 esp_common_ivlen, esp_cbc_decrypt,
153 esp_cbc_encrypt, esp_blowfish_schedule,
154 esp_blowfish_blockdecrypt, esp_blowfish_blockencrypt, },
155 { 8, 8, esp_cbc_mature, 40, 128, esp_cast128_schedlen,
157 esp_common_ivlen, esp_cbc_decrypt,
158 esp_cbc_encrypt, esp_cast128_schedule,
159 esp_cast128_blockdecrypt, esp_cast128_blockencrypt, },
160 { 16, 16, esp_cbc_mature, 128, 256, esp_rijndael_schedlen,
162 esp_common_ivlen, esp_cbc_decrypt,
163 esp_cbc_encrypt, esp_rijndael_schedule,
164 esp_rijndael_blockdecrypt, esp_rijndael_blockencrypt },
165 { 16, 8, esp_aesctr_mature, 160, 288, esp_aesctr_schedlen, "aes-ctr",
166 esp_common_ivlen, esp_aesctr_decrypt,
167 esp_aesctr_encrypt, esp_aesctr_schedule },
168 { 16, 16, esp_cbc_mature, 128, 256, esp_camellia_schedlen,
170 esp_common_ivlen, esp_cbc_decrypt,
171 esp_cbc_encrypt, esp_camellia_schedule,
172 esp_camellia_blockdecrypt, esp_camellia_blockencrypt },
175 const struct esp_algorithm *
176 esp_algorithm_lookup(int idx)
180 case SADB_EALG_DESCBC:
181 return &esp_algorithms[0];
182 case SADB_EALG_3DESCBC:
183 return &esp_algorithms[1];
185 return &esp_algorithms[2];
186 case SADB_X_EALG_BLOWFISHCBC:
187 return &esp_algorithms[3];
188 case SADB_X_EALG_CAST128CBC:
189 return &esp_algorithms[4];
190 case SADB_X_EALG_RIJNDAELCBC:
191 return &esp_algorithms[5];
192 case SADB_X_EALG_AESCTR:
193 return &esp_algorithms[6];
194 case SADB_X_EALG_CAMELLIACBC:
195 return &esp_algorithms[7];
208 for (idx = 0; idx < sizeof(esp_algorithms)/sizeof(esp_algorithms[0]);
210 if (esp_algorithms[idx].ivlenval > ivlen)
211 ivlen = esp_algorithms[idx].ivlenval;
217 esp_schedule(const struct esp_algorithm *algo, struct secasvar *sav)
221 /* check for key length */
222 if (_KEYBITS(sav->key_enc) < algo->keymin ||
223 _KEYBITS(sav->key_enc) > algo->keymax) {
225 "esp_schedule %s: unsupported key length %d: "
226 "needs %d to %d bits\n", algo->name, _KEYBITS(sav->key_enc),
227 algo->keymin, algo->keymax));
231 /* already allocated */
232 if (sav->sched && sav->schedlen != 0)
234 /* no schedule necessary */
235 if (!algo->schedule || !algo->schedlen)
238 sav->schedlen = (*algo->schedlen)(algo);
239 sav->sched = kmalloc(sav->schedlen, M_SECA, M_NOWAIT);
245 error = (*algo->schedule)(algo, sav);
247 ipseclog((LOG_ERR, "esp_schedule %s: error %d\n",
249 bzero(sav->sched, sav->schedlen);
250 kfree(sav->sched, M_SECA);
258 esp_null_mature(struct secasvar *sav)
261 /* anything is okay */
266 esp_null_decrypt(struct mbuf *m,
267 size_t off, /* offset to ESP header */
268 struct secasvar *sav, const struct esp_algorithm *algo,
272 return 0; /* do nothing */
276 esp_null_encrypt(struct mbuf *m,
277 size_t off, /* offset to ESP header */
278 size_t plen, struct secasvar *sav,
279 const struct esp_algorithm *algo, int ivlen)
282 return 0; /* do nothing */
286 esp_descbc_mature(struct secasvar *sav)
288 const struct esp_algorithm *algo;
290 if (!(sav->flags & SADB_X_EXT_OLD) && (sav->flags & SADB_X_EXT_IV4B)) {
291 ipseclog((LOG_ERR, "esp_cbc_mature: "
292 "algorithm incompatible with 4 octets IV length\n"));
297 ipseclog((LOG_ERR, "esp_descbc_mature: no key is given.\n"));
301 algo = esp_algorithm_lookup(sav->alg_enc);
304 "esp_descbc_mature: unsupported algorithm.\n"));
308 if (_KEYBITS(sav->key_enc) < algo->keymin ||
309 _KEYBITS(sav->key_enc) > algo->keymax) {
311 "esp_descbc_mature: invalid key length %d.\n",
312 _KEYBITS(sav->key_enc)));
317 if (des_is_weak_key((des_cblock *)_KEYBUF(sav->key_enc))) {
319 "esp_descbc_mature: weak key was passed.\n"));
327 esp_descbc_ivlen(const struct esp_algorithm *algo, struct secasvar *sav)
332 if ((sav->flags & SADB_X_EXT_OLD) && (sav->flags & SADB_X_EXT_IV4B))
334 if (!(sav->flags & SADB_X_EXT_OLD) && (sav->flags & SADB_X_EXT_DERIV))
340 esp_des_schedlen(const struct esp_algorithm *algo)
343 return sizeof(des_key_schedule);
347 esp_des_schedule(const struct esp_algorithm *algo, struct secasvar *sav)
350 if (des_key_sched((des_cblock *)_KEYBUF(sav->key_enc),
351 *(des_key_schedule *)sav->sched))
358 esp_des_blockdecrypt(const struct esp_algorithm *algo, struct secasvar *sav,
359 u_int8_t *s, u_int8_t *d)
362 /* assumption: d has a good alignment */
363 bcopy(s, d, sizeof(DES_LONG) * 2);
364 des_ecb_encrypt((des_cblock *)d, (des_cblock *)d,
365 *(des_key_schedule *)sav->sched, DES_DECRYPT);
370 esp_des_blockencrypt(const struct esp_algorithm *algo, struct secasvar *sav,
371 u_int8_t *s, u_int8_t *d)
374 /* assumption: d has a good alignment */
375 bcopy(s, d, sizeof(DES_LONG) * 2);
376 des_ecb_encrypt((des_cblock *)d, (des_cblock *)d,
377 *(des_key_schedule *)sav->sched, DES_ENCRYPT);
382 esp_cbc_mature(struct secasvar *sav)
385 const struct esp_algorithm *algo;
387 if (sav->flags & SADB_X_EXT_OLD) {
389 "esp_cbc_mature: algorithm incompatible with esp-old\n"));
392 if (sav->flags & SADB_X_EXT_DERIV) {
394 "esp_cbc_mature: algorithm incompatible with derived\n"));
399 ipseclog((LOG_ERR, "esp_cbc_mature: no key is given.\n"));
403 algo = esp_algorithm_lookup(sav->alg_enc);
406 "esp_cbc_mature %s: unsupported algorithm.\n", algo->name));
410 keylen = sav->key_enc->sadb_key_bits;
411 if (keylen < algo->keymin || algo->keymax < keylen) {
413 "esp_cbc_mature %s: invalid key length %d.\n",
414 algo->name, sav->key_enc->sadb_key_bits));
417 switch (sav->alg_enc) {
418 case SADB_EALG_3DESCBC:
420 if (des_is_weak_key((des_cblock *)_KEYBUF(sav->key_enc)) ||
421 des_is_weak_key((des_cblock *)(_KEYBUF(sav->key_enc) + 8)) ||
422 des_is_weak_key((des_cblock *)(_KEYBUF(sav->key_enc) + 16))) {
424 "esp_cbc_mature %s: weak key was passed.\n",
429 case SADB_X_EALG_BLOWFISHCBC:
430 case SADB_X_EALG_CAST128CBC:
432 case SADB_X_EALG_RIJNDAELCBC:
433 case SADB_X_EALG_CAMELLIACBC:
434 /* allows specific key sizes only */
435 if (!(keylen == 128 || keylen == 192 || keylen == 256)) {
437 "esp_cbc_mature %s: invalid key length %d.\n",
438 algo->name, keylen));
448 esp_blowfish_schedlen(const struct esp_algorithm *algo)
451 return sizeof(BF_KEY);
455 esp_blowfish_schedule(const struct esp_algorithm *algo, struct secasvar *sav)
458 BF_set_key((BF_KEY *)sav->sched, _KEYLEN(sav->key_enc),
459 _KEYBUF(sav->key_enc));
464 esp_blowfish_blockdecrypt(const struct esp_algorithm *algo,
465 struct secasvar *sav, u_int8_t *s, u_int8_t *d)
468 BF_ecb_encrypt(s, d, (BF_KEY *)sav->sched, 0);
473 esp_blowfish_blockencrypt(const struct esp_algorithm *algo,
474 struct secasvar *sav, u_int8_t *s, u_int8_t *d)
477 BF_ecb_encrypt(s, d, (BF_KEY *)sav->sched, 1);
482 esp_cast128_schedlen(const struct esp_algorithm *algo)
485 return sizeof(cast128_key);
489 esp_cast128_schedule(const struct esp_algorithm *algo, struct secasvar *sav)
492 cast128_setkey((cast128_key *)sav->sched, _KEYBUF(sav->key_enc),
493 _KEYLEN(sav->key_enc));
498 esp_cast128_blockdecrypt(const struct esp_algorithm *algo,
499 struct secasvar *sav, u_int8_t *s, u_int8_t *d)
502 cast128_decrypt((cast128_key *)sav->sched, s, d);
507 esp_cast128_blockencrypt(const struct esp_algorithm *algo, struct secasvar *sav,
508 u_int8_t *s, u_int8_t *d)
511 cast128_encrypt((cast128_key *)sav->sched, s, d);
516 esp_3des_schedlen(const struct esp_algorithm *algo)
519 return sizeof(des_key_schedule) * 3;
523 esp_3des_schedule(const struct esp_algorithm *algo, struct secasvar *sav)
530 p = (des_key_schedule *)sav->sched;
531 k = _KEYBUF(sav->key_enc);
532 for (i = 0; i < 3; i++) {
533 error = des_key_sched((des_cblock *)(k + 8 * i), p[i]);
541 esp_3des_blockdecrypt(const struct esp_algorithm *algo, struct secasvar *sav,
542 u_int8_t *s, u_int8_t *d)
546 /* assumption: d has a good alignment */
547 p = (des_key_schedule *)sav->sched;
548 bcopy(s, d, sizeof(DES_LONG) * 2);
549 des_ecb3_encrypt((des_cblock *)d, (des_cblock *)d,
550 p[0], p[1], p[2], DES_DECRYPT);
555 esp_3des_blockencrypt(const struct esp_algorithm *algo, struct secasvar *sav,
556 u_int8_t *s, u_int8_t *d)
560 /* assumption: d has a good alignment */
561 p = (des_key_schedule *)sav->sched;
562 bcopy(s, d, sizeof(DES_LONG) * 2);
563 des_ecb3_encrypt((des_cblock *)d, (des_cblock *)d,
564 p[0], p[1], p[2], DES_ENCRYPT);
569 esp_common_ivlen(const struct esp_algorithm *algo, struct secasvar *sav)
573 panic("esp_common_ivlen: unknown algorithm");
574 return algo->ivlenval;
578 esp_cbc_decrypt(struct mbuf *m, size_t off, struct secasvar *sav,
579 const struct esp_algorithm *algo, int ivlen)
582 struct mbuf *d, *d0, *dp;
583 int soff, doff; /* offset from the head of chain, to head of this mbuf */
584 int sn, dn; /* offset from the head of the mbuf, to meat */
585 size_t ivoff, bodyoff;
586 u_int8_t iv[MAXIVLEN], *ivp;
587 u_int8_t sbuf[MAXIVLEN], *sp;
595 if (ivlen != sav->ivlen || ivlen > sizeof(iv)) {
596 ipseclog((LOG_ERR, "esp_cbc_decrypt %s: "
597 "unsupported ivlen %d\n", algo->name, ivlen));
602 /* assumes blocklen == padbound */
603 blocklen = algo->padbound;
606 if (blocklen > sizeof(iv)) {
607 ipseclog((LOG_ERR, "esp_cbc_decrypt %s: "
608 "unsupported blocklen %d\n", algo->name, blocklen));
614 if (sav->flags & SADB_X_EXT_OLD) {
616 ivoff = off + sizeof(struct esp);
617 bodyoff = off + sizeof(struct esp) + ivlen;
621 if (sav->flags & SADB_X_EXT_DERIV) {
623 * draft-ietf-ipsec-ciph-des-derived-00.txt
624 * uses sequence number field as IV field.
626 ivoff = off + sizeof(struct esp);
627 bodyoff = off + sizeof(struct esp) + sizeof(u_int32_t);
628 ivlen = sizeof(u_int32_t);
631 ivoff = off + sizeof(struct newesp);
632 bodyoff = off + sizeof(struct newesp) + ivlen;
638 m_copydata(m, ivoff, ivlen, (caddr_t)iv);
641 if (ivlen == blocklen)
643 else if (ivlen == 4 && blocklen == 8) {
644 bcopy(&iv[0], &iv[4], 4);
650 ipseclog((LOG_ERR, "esp_cbc_encrypt %s: "
651 "unsupported ivlen/blocklen: %d %d\n",
652 algo->name, ivlen, blocklen));
657 if (m->m_pkthdr.len < bodyoff) {
658 ipseclog((LOG_ERR, "esp_cbc_decrypt %s: bad len %d/%lu\n",
659 algo->name, m->m_pkthdr.len, (unsigned long)bodyoff));
663 if ((m->m_pkthdr.len - bodyoff) % blocklen) {
664 ipseclog((LOG_ERR, "esp_cbc_decrypt %s: "
665 "payload length must be multiple of %d\n",
666 algo->name, blocklen));
673 soff = doff = sn = dn = 0;
677 while (soff < bodyoff) {
678 if (soff + s->m_len >= bodyoff) {
689 /* skip over empty mbuf */
690 while (s && s->m_len == 0)
693 while (soff < m->m_pkthdr.len) {
695 if (sn + blocklen <= s->m_len) {
696 /* body is continuous */
697 sp = mtod(s, u_int8_t *) + sn;
699 /* body is non-continuous */
700 m_copydata(s, sn, blocklen, sbuf);
705 if (!d || dn + blocklen > d->m_len) {
708 i = m->m_pkthdr.len - (soff + sn);
709 d = m_getb(i, MB_DONTWAIT, MT_DATA, 0);
721 d->m_len = rounddown(M_TRAILINGSPACE(d), blocklen);
728 (*algo->blockdecrypt)(algo, sav, sp, mtod(d, u_int8_t *) + dn);
732 q = mtod(d, u_int8_t *) + dn;
733 for (i = 0; i < blocklen; i++)
738 bcopy(sbuf, iv, blocklen);
746 /* find the next source block */
747 while (s && sn >= s->m_len) {
753 /* skip over empty mbuf */
754 while (s && s->m_len == 0)
758 m_freem(scut->m_next);
759 scut->m_len = scutoff;
763 bzero(iv, sizeof(iv));
764 bzero(sbuf, sizeof(sbuf));
770 esp_cbc_encrypt(struct mbuf *m, size_t off, size_t plen, struct secasvar *sav,
771 const struct esp_algorithm *algo, int ivlen)
774 struct mbuf *d, *d0, *dp;
775 int soff, doff; /* offset from the head of chain, to head of this mbuf */
776 int sn, dn; /* offset from the head of the mbuf, to meat */
777 size_t ivoff, bodyoff;
778 u_int8_t iv[MAXIVLEN], *ivp;
779 u_int8_t sbuf[MAXIVLEN], *sp;
787 if (ivlen != sav->ivlen || ivlen > sizeof(iv)) {
788 ipseclog((LOG_ERR, "esp_cbc_encrypt %s: "
789 "unsupported ivlen %d\n", algo->name, ivlen));
794 /* assumes blocklen == padbound */
795 blocklen = algo->padbound;
798 if (blocklen > sizeof(iv)) {
799 ipseclog((LOG_ERR, "esp_cbc_encrypt %s: "
800 "unsupported blocklen %d\n", algo->name, blocklen));
806 if (sav->flags & SADB_X_EXT_OLD) {
808 ivoff = off + sizeof(struct esp);
809 bodyoff = off + sizeof(struct esp) + ivlen;
813 if (sav->flags & SADB_X_EXT_DERIV) {
815 * draft-ietf-ipsec-ciph-des-derived-00.txt
816 * uses sequence number field as IV field.
818 ivoff = off + sizeof(struct esp);
819 bodyoff = off + sizeof(struct esp) + sizeof(u_int32_t);
820 ivlen = sizeof(u_int32_t);
823 ivoff = off + sizeof(struct newesp);
824 bodyoff = off + sizeof(struct newesp) + ivlen;
829 /* put iv into the packet. if we are in derived mode, use seqno. */
831 m_copydata(m, ivoff, ivlen, (caddr_t)iv);
833 bcopy(sav->iv, iv, ivlen);
834 /* maybe it is better to overwrite dest, not source */
835 m_copyback(m, ivoff, ivlen, (caddr_t)iv);
839 if (ivlen == blocklen)
841 else if (ivlen == 4 && blocklen == 8) {
842 bcopy(&iv[0], &iv[4], 4);
848 ipseclog((LOG_ERR, "esp_cbc_encrypt %s: "
849 "unsupported ivlen/blocklen: %d %d\n",
850 algo->name, ivlen, blocklen));
855 if (m->m_pkthdr.len < bodyoff) {
856 ipseclog((LOG_ERR, "esp_cbc_encrypt %s: bad len %d/%lu\n",
857 algo->name, m->m_pkthdr.len, (unsigned long)bodyoff));
861 if ((m->m_pkthdr.len - bodyoff) % blocklen) {
862 ipseclog((LOG_ERR, "esp_cbc_encrypt %s: "
863 "payload length must be multiple of %lu\n",
864 algo->name, (unsigned long)algo->padbound));
871 soff = doff = sn = dn = 0;
875 while (soff < bodyoff) {
876 if (soff + s->m_len >= bodyoff) {
887 /* skip over empty mbuf */
888 while (s && s->m_len == 0)
891 while (soff < m->m_pkthdr.len) {
893 if (sn + blocklen <= s->m_len) {
894 /* body is continuous */
895 sp = mtod(s, u_int8_t *) + sn;
897 /* body is non-continuous */
898 m_copydata(s, sn, blocklen, (caddr_t)sbuf);
903 if (!d || dn + blocklen > d->m_len) {
906 i = m->m_pkthdr.len - (soff + sn);
907 d = m_getb(i, MB_DONTWAIT, MT_DATA, 0);
919 d->m_len = rounddown(M_TRAILINGSPACE(d), blocklen);
928 for (i = 0; i < blocklen; i++)
932 (*algo->blockencrypt)(algo, sav, sp, mtod(d, u_int8_t *) + dn);
935 ivp = mtod(d, u_int8_t *) + dn;
940 /* find the next source block */
941 while (s && sn >= s->m_len) {
947 /* skip over empty mbuf */
948 while (s && s->m_len == 0)
952 m_freem(scut->m_next);
953 scut->m_len = scutoff;
957 bzero(iv, sizeof(iv));
958 bzero(sbuf, sizeof(sbuf));
965 /*------------------------------------------------------------*/
967 /* does not free m0 on error */
969 esp_auth(struct mbuf *m0,
970 size_t skip, /* offset to ESP header */
971 size_t length, /* payload length */
972 struct secasvar *sav, u_char *sum)
976 struct ah_algorithm_state s;
977 u_char sumbuf[AH_MAXSUMSIZE];
978 const struct ah_algorithm *algo;
983 if (m0->m_pkthdr.len < skip) {
984 ipseclog((LOG_DEBUG, "esp_auth: mbuf length < skip\n"));
987 if (m0->m_pkthdr.len < skip + length) {
989 "esp_auth: mbuf length < skip + length\n"));
993 * length of esp part (excluding authentication data) must be 4n,
994 * since nexthdr must be at offset 4n+3.
997 ipseclog((LOG_ERR, "esp_auth: length is not multiple of 4\n"));
1001 ipseclog((LOG_DEBUG, "esp_auth: NULL SA passed\n"));
1004 algo = ah_algorithm_lookup(sav->alg_auth);
1007 "esp_auth: bad ESP auth algorithm passed: %d\n",
1015 siz = (((*algo->sumsiz)(sav) + 3) & ~(4 - 1));
1016 if (sizeof(sumbuf) < siz) {
1017 ipseclog((LOG_DEBUG,
1018 "esp_auth: AH_MAXSUMSIZE is too small: siz=%lu\n",
1023 /* skip the header */
1026 panic("mbuf chain?");
1027 if (m->m_len <= skip) {
1037 error = (*algo->init)(&s, sav);
1041 while (0 < length) {
1043 panic("mbuf chain?");
1045 if (m->m_len - off < length) {
1046 (*algo->update)(&s, mtod(m, u_char *) + off,
1048 length -= m->m_len - off;
1052 (*algo->update)(&s, mtod(m, u_char *) + off, length);
1056 (*algo->result)(&s, sumbuf);
1057 bcopy(sumbuf, sum, siz); /* XXX */