Subversion Repositories or1k

/* SCTP kernel reference Implementation
 * Copyright (c) 1999-2000 Cisco, Inc.
 * Copyright (c) 1999-2001 Motorola, Inc.
 * 
 * This file is part of the SCTP kernel reference Implementation
 * 
 * (It's really SHA-1 but Hey I was tired when I created this 
 * file, and on a plane to France :-)
 * 
 * The SCTP reference implementation is free software; 
 * you can redistribute it and/or modify it under the terms of 
 * the GNU General Public License as published by
 * the Free Software Foundation; either version 2, or (at your option)
 * any later version.
 * 
 * The SCTP reference implementation is distributed in the hope that it 
 * will be useful, but WITHOUT ANY WARRANTY; without even the implied
 *                 ************************
 * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with GNU CC; see the file COPYING.  If not, write to
 * the Free Software Foundation, 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.  
 * 
 * Please send any bug reports or fixes you make to the
 * email address(es):
 *    lksctp developers <lksctp-developers@lists.sourceforge.net>
 * 
 * Or submit a bug report through the following website:
 *    http://www.sf.net/projects/lksctp
 *
 * Written or modified by: 
 *    Randall Stewart <rstewar1@email.mot.com>
 *    kmorneau@cisco.com
 *    qxie1@email.mot.com
 *
 * Based on:
 *    Randy Stewart, et al. SCTP Reference Implementation which is licenced
 *    under the GPL. 
 * 
 * Any bugs reported given to us we will try to fix... any fixes shared will
 * be incorporated into the next SCTP release.
 */
 
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/fcntl.h>
#include <asm/string.h>		/* for memcpy */
#include <linux/sched.h>	/* dead chicken for in.h */
#include <linux/in.h>		/* for htonl and ntohl */
 
#include <net/sctp/sla1.h>
 
void SLA1_Init(struct SLA_1_Context *ctx)
{
	/* Init the SLA-1 context structure.  */
	ctx->A = 0;
	ctx->B = 0;
	ctx->C = 0;
	ctx->D = 0;
	ctx->E = 0;
	ctx->H0 = H0INIT;
	ctx->H1 = H1INIT;
	ctx->H2 = H2INIT;
	ctx->H3 = H3INIT;
	ctx->H4 = H4INIT;
	ctx->TEMP = 0;
	memset(ctx->words, 0, sizeof(ctx->words));
	ctx->howManyInBlock = 0;
	ctx->runningTotal = 0;
}
 
void SLA1processABlock(struct SLA_1_Context *ctx,unsigned int *block)
{
	int i;
	/* init the W0-W15 to the block of words being
	 * hashed.
	 */
	/* step a) */
 
	for (i = 0; i < 16; i++)
		ctx->words[i] = ntohl(block[i]);
 
	/* now init the rest based on the SLA-1 formula, step b) */
	for (i = 16; i < 80; i++)
		ctx->words[i] =
			CSHIFT(1, ((ctx->words[(i-3)]) ^
				   (ctx->words[(i-8)]) ^
				   (ctx->words[(i-14)]) ^
				   (ctx->words[(i-16)])));
 
	/* step c) */
	ctx->A = ctx->H0;
	ctx->B = ctx->H1;
	ctx->C = ctx->H2;
	ctx->D = ctx->H3;
	ctx->E = ctx->H4;
 
	/* step d) */
	for (i = 0; i < 80; i++) {
		if (i < 20) {
			ctx->TEMP = ((CSHIFT(5, ctx->A)) +
				     (F1(ctx->B, ctx->C, ctx->D)) +
				     (ctx->E) +
				     ctx->words[i] +
				     K1
				);
		} else if (i < 40) {
			ctx->TEMP = ((CSHIFT(5, ctx->A)) +
				     (F2(ctx->B, ctx->C, ctx->D)) +
				     (ctx->E) +
				     (ctx->words[i]) +
				     K2
				);
		} else if (i < 60) {
			ctx->TEMP = ((CSHIFT(5, ctx->A)) +
				     (F3(ctx->B, ctx->C, ctx->D)) +
				     (ctx->E) +
				     (ctx->words[i]) +
				     K3
				);
		} else {
			ctx->TEMP = ((CSHIFT(5, ctx->A)) +
				     (F4(ctx->B, ctx->C, ctx->D)) +
				     (ctx->E) +
				     (ctx->words[i]) +
				     K4
				);
		}
		ctx->E = ctx->D;
		ctx->D = ctx->C;
		ctx->C = CSHIFT(30, ctx->B);
		ctx->B = ctx->A;
		ctx->A = ctx->TEMP;
	}
 
	/* step e) */
	ctx->H0 = (ctx->H0) + (ctx->A);
	ctx->H1 = (ctx->H1) + (ctx->B);
	ctx->H2 = (ctx->H2) + (ctx->C);
	ctx->H3 = (ctx->H3) + (ctx->D);
	ctx->H4 = (ctx->H4) + (ctx->E);
}
 
void SLA1_Process(struct SLA_1_Context *ctx, const unsigned char *ptr, int siz)
{
	int numberLeft, leftToFill;
 
	numberLeft = siz;
	while (numberLeft > 0) {
		leftToFill = sizeof(ctx->SLAblock) - ctx->howManyInBlock;
		if (leftToFill > numberLeft) {
			/* can only partially fill up this one */
			memcpy(&ctx->SLAblock[ctx->howManyInBlock],
			       ptr, numberLeft);
			ctx->howManyInBlock += siz;
			ctx->runningTotal += siz;
			break;
		} else {
			/* block is now full, process it */
			memcpy(&ctx->SLAblock[ctx->howManyInBlock],
			       ptr, leftToFill);
			SLA1processABlock(ctx, (unsigned int *) ctx->SLAblock);
			numberLeft -= leftToFill;
			ctx->runningTotal += leftToFill;
			ctx->howManyInBlock = 0;
		}
	}
}
 
void SLA1_Final(struct SLA_1_Context *ctx, unsigned char *digestBuf)
{
	/* if any left in block fill with padding
	 * and process. Then transfer the digest to
	 * the pointer. At the last block some special
	 * rules need to apply. We must add a 1 bit
	 * following the message, then we pad with
	 * 0's. The total size is encoded as a 64 bit
	 * number at the end. Now if the last buffer has
	 * more than 55 octets in it we cannot fit
	 * the 64 bit number + 10000000 pad on the end
	 * and must add the 10000000 pad, pad the rest
	 * of the message with 0's and then create a
	 * all 0 message with just the 64 bit size
	 * at the end and run this block through by itself.
	 * Also the 64 bit int must be in network byte
	 * order.
	 */
	int i, leftToFill;
	unsigned int *ptr;
 
	if (ctx->howManyInBlock > 55) {
		/* special case, we need to process two
		 * blocks here. One for the current stuff
		 * plus possibly the pad. The other for
		 * the size.
		 */
		leftToFill = sizeof(ctx->SLAblock) - ctx->howManyInBlock;
		if (leftToFill == 0) {
			/* Should not really happen but I am paranoid */
			/* Not paranoid enough!  It is possible for leftToFill
			 * to become negative!  AAA!!!!  This is another reason
			 * to pick MD5 :-)...
			 */
			SLA1processABlock(ctx, (unsigned int *) ctx->SLAblock);
			/* init last block, a bit different then the rest :-) */
			ctx->SLAblock[0] = 0x80;
			for (i = 1; i < sizeof(ctx->SLAblock); i++) {
				ctx->SLAblock[i] = 0x0;
			}
		} else if (leftToFill == 1) {
			ctx->SLAblock[ctx->howManyInBlock] = 0x80;
			SLA1processABlock(ctx, (unsigned int *) ctx->SLAblock);
			/* init last block */
			memset(ctx->SLAblock, 0, sizeof(ctx->SLAblock));
		} else {
			ctx->SLAblock[ctx->howManyInBlock] = 0x80;
			for (i = (ctx->howManyInBlock + 1);
			     i < sizeof(ctx->SLAblock);
			     i++) {
				ctx->SLAblock[i] = 0x0;
			}
			SLA1processABlock(ctx, (unsigned int *) ctx->SLAblock);
			/* init last block */
			memset(ctx->SLAblock, 0, sizeof(ctx->SLAblock));
		}
		/* This is in bits so multiply by 8 */
		ctx->runningTotal *= 8;
		ptr = (unsigned int *) &ctx->SLAblock[60];
		*ptr = htonl(ctx->runningTotal);
		SLA1processABlock(ctx, (unsigned int *) ctx->SLAblock);
	} else {
		/* easy case, we just pad this
		 * message to size - end with 0
		 * add the magic 0x80 to the next
		 * word and then put the network byte
		 * order size in the last spot and
		 * process the block.
		 */
		ctx->SLAblock[ctx->howManyInBlock] = 0x80;
		for (i = (ctx->howManyInBlock + 1);
		     i < sizeof(ctx->SLAblock);
		     i++) {
			ctx->SLAblock[i] = 0x0;
		}
		/* get last int spot */
		ctx->runningTotal *= 8;
		ptr = (unsigned int *) &ctx->SLAblock[60];
		*ptr = htonl(ctx->runningTotal);
		SLA1processABlock(ctx, (unsigned int *) ctx->SLAblock);
	}
	/* Now at this point all we need do is transfer the
	 * digest back to the user
	 */
	digestBuf[3] = (ctx->H0 & 0xff);
	digestBuf[2] = ((ctx->H0 >> 8) & 0xff);
	digestBuf[1] = ((ctx->H0 >> 16) & 0xff);
	digestBuf[0] = ((ctx->H0 >> 24) & 0xff);
 
	digestBuf[7] = (ctx->H1 & 0xff);
	digestBuf[6] = ((ctx->H1 >> 8) & 0xff);
	digestBuf[5] = ((ctx->H1 >> 16) & 0xff);
	digestBuf[4] = ((ctx->H1 >> 24) & 0xff);
 
	digestBuf[11] = (ctx->H2 & 0xff);
	digestBuf[10] = ((ctx->H2 >> 8) & 0xff);
	digestBuf[9] = ((ctx->H2 >> 16) & 0xff);
	digestBuf[8] = ((ctx->H2 >> 24) & 0xff);
 
	digestBuf[15] = (ctx->H3 & 0xff);
	digestBuf[14] = ((ctx->H3 >> 8) & 0xff);
	digestBuf[13] = ((ctx->H3 >> 16) & 0xff);
	digestBuf[12] = ((ctx->H3 >> 24) & 0xff);
 
	digestBuf[19] = (ctx->H4 & 0xff);
	digestBuf[18] = ((ctx->H4 >> 8) & 0xff);
	digestBuf[17] = ((ctx->H4 >> 16) & 0xff);
	digestBuf[16] = ((ctx->H4 >> 24) & 0xff);
}