[apple/xnu.git] / bsd / crypto / cast128 / cast128_cbc.c

/*
 * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the name of the project nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */
/*
 * based on sys/crypto/des/des_cbc.c, rewrote by Tomomi Suzuki
 */

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/mbuf.h>
#include <crypto/cast128/cast128.h>


void
cast128_cbc_process(m0, skip, length, subkey, iv, keylen, mode)
	struct mbuf *m0;
	size_t skip;
	size_t length;
	u_int32_t *subkey;
	u_int8_t *iv;
	size_t keylen;
	int mode;
{
	struct mbuf *m;
	u_int8_t inbuf[8], outbuf[8];
	size_t off;

	/* sanity check */
	if (m0->m_pkthdr.len < skip) {
		printf("cast128_cbc_process: mbuf length < skip\n");
		return;
	}
	if (m0->m_pkthdr.len < length) {
		printf("cast128_cbc_process: mbuf length < encrypt length\n");
		return;
	}
	if (m0->m_pkthdr.len < skip + length) {
		printf("cast128_cbc_process: "
			"mbuf length < skip + encrypt length\n");
		return;
	}
	if (length % 8) {
		printf("cast128_cbc_process: length is not multiple of 8\n");
		return;
	}

	m = m0;
	off = 0;

	/* skip over the header */
	while (skip) {
		if (!m)
			panic("cast128_cbc_process: mbuf chain?\n");
		if (m->m_len <= skip) {
			skip -= m->m_len;
			m = m->m_next;
			off = 0;
		} else {
			off = skip;
			skip = 0;
		}
	}

	/* copy iv into outbuf for XOR (encrypt) */
	bcopy(iv, outbuf, 8);

	/*
	 * encrypt/decrypt packet
	 */
	while (length > 0) {
		int i;

		if (!m)
			panic("cast128_cbc_process: mbuf chain?\n");

		/*
		 * copy the source into input buffer.
		 * don't update off or m, since we need to use them
		 * later.
		 */
		if (off + 8 <= m->m_len)
			bcopy(mtod(m, u_int8_t *)+off, inbuf, 8);
		else {
			struct mbuf *n;
			size_t noff;
			u_int8_t *p, *in;

			n = m;
			noff = off;
			p = mtod(n, u_int8_t *) + noff;

			in = inbuf;
			while (in - inbuf < 8) {
				if (!p) {
					panic("cast128_cbc_process: "
						"mbuf chain?\n");
				}
				*in++ = *p++;
				noff++;
				if (noff < n->m_len)
					continue;
				do {
					n = n->m_next;
				} while (n && !n->m_len);
				noff = 0;
				if (n)
					p = mtod(n, u_int8_t *);
				else
					p = NULL;
			}
		}

		/* encrypt/decrypt */
		switch (mode) {
		case CAST128_ENCRYPT:
			/* XOR */
			for (i = 0; i < 8; i++)
				inbuf[i] ^= outbuf[i];

			/* encrypt */
			if (keylen <= 80/8)
				cast128_encrypt_round12(outbuf, inbuf, subkey);
			else
				cast128_encrypt_round16(outbuf, inbuf, subkey);
			break;

		case CAST128_DECRYPT:
			/* decrypt */
			if (keylen <= 80/8)
				cast128_decrypt_round12(outbuf, inbuf, subkey);
			else
				cast128_decrypt_round16(outbuf, inbuf, subkey);

			/* XOR */
			for (i = 0; i < 8; i++)
				outbuf[i] ^= iv[i];

			/* copy inbuf into iv for next XOR */
			bcopy(inbuf, iv, 8);
			break;
		}

		/*
		 * copy the output buffer into the result.
		 * need to update off and m.
		 */
		if (off + 8 < m->m_len) {
			bcopy(outbuf, mtod(m, u_int8_t *) + off, 8);
			off += 8;
		} else if (off + 8 == m->m_len) {
			bcopy(outbuf, mtod(m, u_int8_t *) + off, 8);
			do {
				m = m->m_next;
			} while (m && !m->m_len);
			off = 0;
		} else {
			struct mbuf *n;
			size_t noff;
			u_int8_t *p, *out;

			n = m;
			noff = off;
			p = mtod(n, u_int8_t *) + noff;

			out = outbuf;
			while (out - outbuf < 8) {
				if (!p) {
					panic("cast128_cbc_process: "
						"mbuf chain?\n");
				}
				*p++ = *out++;
				noff++;
				if (noff < n->m_len)
					continue;
				do {
					n = n->m_next;
				} while (n && !n->m_len);
				noff = 0;
				if (n)
					p = mtod(n, u_int8_t *);
				else
					p = NULL;
			}

			m = n;
			off = noff;
		}

		length -= 8;
	}
}
Commit	Line	Data
1c79356b A	1	/*
	2	* Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
	3	* All rights reserved.
	4	*
	5	* Redistribution and use in source and binary forms, with or without
	6	* modification, are permitted provided that the following conditions
	7	* are met:
	8	* 1. Redistributions of source code must retain the above copyright
	9	* notice, this list of conditions and the following disclaimer.
	10	* 2. Redistributions in binary form must reproduce the above copyright
	11	* notice, this list of conditions and the following disclaimer in the
	12	* documentation and/or other materials provided with the distribution.
	13	* 3. Neither the name of the project nor the names of its contributors
	14	* may be used to endorse or promote products derived from this software
	15	* without specific prior written permission.
	16	*
	17	* THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
	18	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	19	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	20	* ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
	21	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
	22	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
	23	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	24	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
	25	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
	26	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
	27	* SUCH DAMAGE.
	28	*/
	29	/*
	30	* based on sys/crypto/des/des_cbc.c, rewrote by Tomomi Suzuki
	31	*/
	32
	33	#include <sys/param.h>
	34	#include <sys/systm.h>
	35	#include <sys/mbuf.h>
	36	#include <crypto/cast128/cast128.h>
	37
	38
	39	void
	40	cast128_cbc_process(m0, skip, length, subkey, iv, keylen, mode)
	41	struct mbuf *m0;
	42	size_t skip;
	43	size_t length;
	44	u_int32_t *subkey;
	45	u_int8_t *iv;
	46	size_t keylen;
	47	int mode;
	48	{
	49	struct mbuf *m;
	50	u_int8_t inbuf[8], outbuf[8];
	51	size_t off;
	52
	53	/* sanity check */
	54	if (m0->m_pkthdr.len < skip) {
	55	printf("cast128_cbc_process: mbuf length < skip\n");
	56	return;
	57	}
	58	if (m0->m_pkthdr.len < length) {
	59	printf("cast128_cbc_process: mbuf length < encrypt length\n");
	60	return;
	61	}
	62	if (m0->m_pkthdr.len < skip + length) {
	63	printf("cast128_cbc_process: "
	64	"mbuf length < skip + encrypt length\n");
65	return;
66	}
67	if (length % 8) {
68	printf("cast128_cbc_process: length is not multiple of 8\n");
69	return;
70	}
71
72	m = m0;
73	off = 0;
74
75	/* skip over the header */
76	while (skip) {
77	if (!m)
78	panic("cast128_cbc_process: mbuf chain?\n");
79	if (m->m_len <= skip) {
80	skip -= m->m_len;
81	m = m->m_next;
82	off = 0;
83	} else {
84	off = skip;
85	skip = 0;
86	}
87	}
88
89	/* copy iv into outbuf for XOR (encrypt) */
90	bcopy(iv, outbuf, 8);
91
92	/*
93	* encrypt/decrypt packet
94	*/
95	while (length > 0) {
96	int i;
97
98	if (!m)
99	panic("cast128_cbc_process: mbuf chain?\n");
100
101	/*
102	* copy the source into input buffer.
103	* don't update off or m, since we need to use them
104	* later.
105	*/
106	if (off + 8 <= m->m_len)
107	bcopy(mtod(m, u_int8_t *)+off, inbuf, 8);
108	else {
109	struct mbuf *n;
110	size_t noff;
111	u_int8_t p, in;
112
113	n = m;
114	noff = off;
115	p = mtod(n, u_int8_t *) + noff;
116
117	in = inbuf;
118	while (in - inbuf < 8) {
119	if (!p) {
120	panic("cast128_cbc_process: "
121	"mbuf chain?\n");
122	}
123	in++ = p++;
124	noff++;
125	if (noff < n->m_len)
126	continue;
127	do {
128	n = n->m_next;
129	} while (n && !n->m_len);
130	noff = 0;
131	if (n)
132	p = mtod(n, u_int8_t *);
133	else
134	p = NULL;
135	}
136	}
137
138	/* encrypt/decrypt */
139	switch (mode) {
140	case CAST128_ENCRYPT:
141	/* XOR */
142	for (i = 0; i < 8; i++)
143	inbuf[i] ^= outbuf[i];
144
145	/* encrypt */
146	if (keylen <= 80/8)
147	cast128_encrypt_round12(outbuf, inbuf, subkey);
148	else
149	cast128_encrypt_round16(outbuf, inbuf, subkey);
150	break;
151
152	case CAST128_DECRYPT:
153	/* decrypt */
154	if (keylen <= 80/8)
155	cast128_decrypt_round12(outbuf, inbuf, subkey);
156	else
157	cast128_decrypt_round16(outbuf, inbuf, subkey);
158
159	/* XOR */
160	for (i = 0; i < 8; i++)
161	outbuf[i] ^= iv[i];
162
163	/* copy inbuf into iv for next XOR */
164	bcopy(inbuf, iv, 8);
165	break;
166	}
167
168	/*
169	* copy the output buffer into the result.
170	* need to update off and m.
171	*/
172	if (off + 8 < m->m_len) {
173	bcopy(outbuf, mtod(m, u_int8_t *) + off, 8);
174	off += 8;
175	} else if (off + 8 == m->m_len) {
176	bcopy(outbuf, mtod(m, u_int8_t *) + off, 8);
177	do {
178	m = m->m_next;
179	} while (m && !m->m_len);
180	off = 0;
181	} else {
182	struct mbuf *n;
183	size_t noff;
184	u_int8_t p, out;
185
186	n = m;
187	noff = off;
188	p = mtod(n, u_int8_t *) + noff;
189
190	out = outbuf;
191	while (out - outbuf < 8) {
192	if (!p) {
193	panic("cast128_cbc_process: "
194	"mbuf chain?\n");
195	}
196	p++ = out++;
197	noff++;
198	if (noff < n->m_len)
199	continue;
200	do {
201	n = n->m_next;
202	} while (n && !n->m_len);
203	noff = 0;
204	if (n)
205	p = mtod(n, u_int8_t *);
206	else
207	p = NULL;
208	}
209
210	m = n;
211	off = noff;
212	}
213
214	length -= 8;
215	}
216	}
217