[apple/xnu.git] / bsd / crypto / des / des_3cbc.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 <crypto/des/des_locl.h>


void des_3cbc_process(m0, skip, length, schedule, ivec, mode)
	struct mbuf *m0;
	size_t skip;
	size_t length;
	des_key_schedule *schedule;
	des_cblock (*ivec);
	int mode;
{
	u_int8_t inbuf[8], outbuf[8];
	struct mbuf *m;
	size_t off;
	DES_LONG tin0, tin1;
	DES_LONG tout0, tout1;
	DES_LONG tin[2];
	DES_LONG xor0 = 0, xor1 = 0;
	u_int8_t *iv;
	u_int8_t *in, *out;

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

	m = m0;
	off = 0;

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

	/* initialize */
	tin0 = tin1 = tout0 = tout1 = 0;
	tin[0] = tin[1] = 0;

	switch (mode) {
	case DES_ENCRYPT:
		iv = (u_int8_t *)ivec;
		c2l(iv, tout0);
		c2l(iv, tout1);
		break;
	case DES_DECRYPT:
		xor0 = xor1 = 0;
		iv = (u_int8_t *)ivec;
		c2l(iv, xor0);
		c2l(iv, xor1);
		break;
	}

	/*
	 * encrypt/decrypt packet
	 */
	while (length > 0) {
		if (!m)
			panic("des_3cbc_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[0], 8);
		else {
			struct mbuf *n;
			size_t noff;
			u_int8_t *p;
			u_int8_t *in;

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

			in = &inbuf[0];
			while (in - &inbuf[0] < 8) {
				if (!p) {
					panic("des_3cbc_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 *) + noff;
				else
					p = NULL;
			}
		}

		/* encrypt/decrypt */
		switch (mode) {
		case DES_ENCRYPT:
			in = &inbuf[0];
			out = &outbuf[0];
			c2l(in, tin0);
			c2l(in, tin1);

			/* XOR */
			tin0 ^= tout0; tin[0] = tin0;
			tin1 ^= tout1; tin[1] = tin1;

			des_encrypt((DES_LONG *)tin, schedule[0], DES_ENCRYPT);
			des_encrypt((DES_LONG *)tin, schedule[1], DES_DECRYPT);
			des_encrypt((DES_LONG *)tin, schedule[2], DES_ENCRYPT);

			tout0 = tin[0]; l2c(tout0, out);
			tout1 = tin[1]; l2c(tout1, out);
			break;
		case DES_DECRYPT:
			in = &inbuf[0];
			out = &outbuf[0];
			c2l(in, tin0); tin[0] = tin0;
			c2l(in, tin1); tin[1] = tin1;

			des_encrypt((DES_LONG *)tin, schedule[2], DES_DECRYPT);
			des_encrypt((DES_LONG *)tin, schedule[1], DES_ENCRYPT);
			des_encrypt((DES_LONG *)tin, schedule[0], DES_DECRYPT);

			/* XOR */
			tout0 = tin[0] ^ xor0;
			tout1 = tin[1] ^ xor1;
			l2c(tout0, out);
			l2c(tout1, out);

			/* for next iv */
			xor0 = tin0;
			xor1 = tin1;
			break;
		}

		/*
		 * copy the output buffer int the result.
		 * need to update off and m.
		 */
		if (off + 8 < m->m_len) {
			bcopy(&outbuf[0], mtod(m, u_int8_t *) + off, 8);
			off += 8;
		} else if (off + 8 == m->m_len) {
			bcopy(&outbuf[0], 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;
			u_int8_t *out;

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

			out = &outbuf[0];
			while (out - &outbuf[0] < 8) {
				if (!p) {
					panic("des_3cbc_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 *) + noff;
				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	#include <crypto/des/des_locl.h>
	33
	34
	35	void des_3cbc_process(m0, skip, length, schedule, ivec, mode)
	36	struct mbuf *m0;
	37	size_t skip;
	38	size_t length;
	39	des_key_schedule *schedule;
	40	des_cblock (*ivec);
	41	int mode;
	42	{
	43	u_int8_t inbuf[8], outbuf[8];
	44	struct mbuf *m;
	45	size_t off;
	46	DES_LONG tin0, tin1;
	47	DES_LONG tout0, tout1;
	48	DES_LONG tin[2];
	49	DES_LONG xor0 = 0, xor1 = 0;
	50	u_int8_t *iv;
	51	u_int8_t in, out;
	52
	53	/* sanity check */
	54	if (m0->m_pkthdr.len < skip) {
	55	printf("des_3cbc_process: mbuf length < skip\n");
	56	return;
	57	}
	58	if (m0->m_pkthdr.len < length) {
	59	printf("des_3cbc_process: mbuf length < encrypt length\n");
	60	return;
	61	}
	62	if (m0->m_pkthdr.len < skip + length) {
	63	printf("des_3cbc_process: mbuf length < "
	64	"skip + encrypt length\n");
65	return;
66	}
67	if (length % 8) {
68	printf("des_3cbc_process: length(%lu) is not multiple of 8\n",
69	(u_long)length);
70	return;
71	}
72
73	m = m0;
74	off = 0;
75
76	/* skip over the header */
77	while (skip) {
78	if (!m)
79	panic("des_3cbc_process: mbuf chain?\n");
80	if (m->m_len <= skip) {
81	skip -= m->m_len;
82	m = m->m_next;
83	off = 0;
84	} else {
85	off = skip;
86	skip = 0;
87	}
88	}
89
90	/* initialize */
91	tin0 = tin1 = tout0 = tout1 = 0;
92	tin[0] = tin[1] = 0;
93
94	switch (mode) {
95	case DES_ENCRYPT:
96	iv = (u_int8_t *)ivec;
97	c2l(iv, tout0);
98	c2l(iv, tout1);
99	break;
100	case DES_DECRYPT:
101	xor0 = xor1 = 0;
102	iv = (u_int8_t *)ivec;
103	c2l(iv, xor0);
104	c2l(iv, xor1);
105	break;
106	}
107
108	/*
109	* encrypt/decrypt packet
110	*/
111	while (length > 0) {
112	if (!m)
113	panic("des_3cbc_process: mbuf chain?\n");
114
115	/*
116	* copy the source into input buffer.
117	* don't update off or m, since we need to use them
118	* later.
119	*/
120	if (off + 8 <= m->m_len)
121	bcopy(mtod(m, u_int8_t *) + off, &inbuf[0], 8);
122	else {
123	struct mbuf *n;
124	size_t noff;
125	u_int8_t *p;
126	u_int8_t *in;
127
128	n = m;
129	noff = off;
130	p = mtod(n, u_int8_t *) + noff;
131
132	in = &inbuf[0];
133	while (in - &inbuf[0] < 8) {
134	if (!p) {
135	panic("des_3cbc_process: "
136	"mbuf chain?\n");
137	}
138	in++ = p++;
139	noff++;
140	if (noff < n->m_len)
141	continue;
142	do {
143	n = n->m_next;
144	} while (n && !n->m_len);
145	noff = 0;
146	if (n)
147	p = mtod(n, u_int8_t *) + noff;
148	else
149	p = NULL;
150	}
151	}
152
153	/* encrypt/decrypt */
154	switch (mode) {
155	case DES_ENCRYPT:
156	in = &inbuf[0];
157	out = &outbuf[0];
158	c2l(in, tin0);
159	c2l(in, tin1);
160
161	/* XOR */
162	tin0 ^= tout0; tin[0] = tin0;
163	tin1 ^= tout1; tin[1] = tin1;
164
165	des_encrypt((DES_LONG *)tin, schedule[0], DES_ENCRYPT);
166	des_encrypt((DES_LONG *)tin, schedule[1], DES_DECRYPT);
167	des_encrypt((DES_LONG *)tin, schedule[2], DES_ENCRYPT);
168
169	tout0 = tin[0]; l2c(tout0, out);
170	tout1 = tin[1]; l2c(tout1, out);
171	break;
172	case DES_DECRYPT:
173	in = &inbuf[0];
174	out = &outbuf[0];
175	c2l(in, tin0); tin[0] = tin0;
176	c2l(in, tin1); tin[1] = tin1;
177
178	des_encrypt((DES_LONG *)tin, schedule[2], DES_DECRYPT);
179	des_encrypt((DES_LONG *)tin, schedule[1], DES_ENCRYPT);
180	des_encrypt((DES_LONG *)tin, schedule[0], DES_DECRYPT);
181
182	/* XOR */
183	tout0 = tin[0] ^ xor0;
184	tout1 = tin[1] ^ xor1;
185	l2c(tout0, out);
186	l2c(tout1, out);
187
188	/* for next iv */
189	xor0 = tin0;
190	xor1 = tin1;
191	break;
192	}
193
194	/*
195	* copy the output buffer int the result.
196	* need to update off and m.
197	*/
198	if (off + 8 < m->m_len) {
199	bcopy(&outbuf[0], mtod(m, u_int8_t *) + off, 8);
200	off += 8;
201	} else if (off + 8 == m->m_len) {
202	bcopy(&outbuf[0], mtod(m, u_int8_t *) + off, 8);
203	do {
204	m = m->m_next;
205	} while (m && !m->m_len);
206	off = 0;
207	} else {
208	struct mbuf *n;
209	size_t noff;
210	u_int8_t *p;
211	u_int8_t *out;
212
213	n = m;
214	noff = off;
215	p = mtod(n, u_int8_t *) + noff;
216
217	out = &outbuf[0];
218	while (out - &outbuf[0] < 8) {
219	if (!p) {
220	panic("des_3cbc_process: "
221	"mbuf chain?\n");
222	}
223	p++ = out++;
224	noff++;
225	if (noff < n->m_len)
226	continue;
227	do {
228	n = n->m_next;
229	} while (n && !n->m_len);
230	noff = 0;
231	if (n)
232	p = mtod(n, u_int8_t *) + noff;
233	else
234	p = NULL;
235	}
236
237	m = n;
238	off = noff;
239	}
240
241	length -= 8;
242	}
243	}
244