des_if.c

SecuDe是一个由安全应用程序接口组成,对验证机制、证件处理、PEM、X.400报文处理和密钥管理提供支持。SecuDe提供DES、 RSA杂凑函数、密钥生成以及数字签名的生成和核实等多种密码机制。

		}
	}

	return(decrypted_octets);
}


void
dedes_cbc(outblock)
char	*outblock;
{
	char	ivtmp[8];
	register char	*cp, *cp1;
	register int	i;


	/* Save incoming ciphertext for chain */

	bcopy(outblock, ivtmp, 8);

	dedes_ecb(outblock);   /* in-block decryption */

	/* Unchain block, save ciphertext for next */

	cp = outblock;
	cp1 = iv;
	for (i = 8; i != 0; i--)	
		*cp++ ^= *cp1++;
	bcopy(ivtmp, iv, 8);
}

void
dedes_ecb(outblock)
char	*outblock;
{
        if(des3) {
                dedes(outblock);
                endes1(outblock);
                dedes(outblock);
        }
        else dedes(outblock);
        return;
}


static
desfirst(keyinfo, des_type)
KeyInfo *keyinfo;
int	des_type;
{
	OctetString *algparm;
	char	*proc = "desfirst";

	if (DESINIT == FALSE) {
		if (desinit(0, des3) < 0) return(-1);
		DESINIT = TRUE;
	}

	if (keyinfo->subjectkey.nbits == 64 && !des3) setkey(keyinfo->subjectkey.bits);
        else if(keyinfo->subjectkey.nbits == 128 && des3) setdoublekey(keyinfo->subjectkey.bits);
	else {
		aux_add_error(EINVALID, "wrong key length", 0, 0, proc);
		return(-1);
	}
	if (des_type == CBC) {
		/* Initialization Vector */
		if ((algparm = (OctetString * )keyinfo->subjectAI->parm))
			if (algparm->noctets == 8) 
				bcopy(algparm->octets, iv, 8);
			else bzero(iv, 8);
	}
	return(0);
}

setdoublekey(key)  /* this is for DES3 only */
char *key;
{
        setkey(key);
        setkey1(key + 8);
        return(0);
}

read_dec(fd, buf, len, key)
int	fd, len;
char	*buf, *key;
{
	Key deskey;
	static FILE *ff;
	static int	first = TRUE, in, des_type, wout;
	static char	work[8], nwork[8], *w, *nw, *ww;
	int	out = 0, rest;
	AlgMode algmode;
	register int	block;
	register char	*bb;
	char	*proc = "read_dec";

	if (!buf && first == FALSE) {
		c_desdone(FALSE);
		fclose(ff);
		first = TRUE;
		return(0);
	}

	if (!len) return(0);

	if (!key || !strlen(key)) return(read(fd, buf, len));

	if (first) {
		deskey.keyref = 0;
		deskey.pse_sel = (PSESel * )0;
		if (sec_string_to_key(key, &deskey) < 0) {
			aux_add_error(EINVALID, "sec_string_to_key failed", 0, 0, proc);
			return(-1);
		}
		algmode = aux_ObjId2AlgMode(deskey.key->subjectAI->objid);
		if (algmode == CBC) des_type = CBC;
		else des_type = ECB;

                des3 = FALSE;

		if (desfirst(deskey.key, des_type) < 0) {
			aux_free_KeyInfo(&(deskey.key));
			aux_add_error(EINVALID, "desfirst failed", 0, 0, proc);
			return(-1);
		}

		aux_free_KeyInfo(&(deskey.key));
		if (!(ff = fdopen(fd, "r"))) {
			aux_add_error(ESYSTEM, "fdopen failed", 0, 0, proc);
			return(-1);
		}
		if ((in = fread(work, 1, 8, ff)) != 8) {
			aux_add_error(ESYSTEM, "fread failed", 0, 0, proc);
			return(-1);
		}

		w = work;
		nw = nwork;
		wout = 0;
		if (des_type == CBC) dedes_cbc(w);
		else dedes_ecb(w);
		first = FALSE;
	}

	bb = buf;

	if (len % 8 == 0 && wout == 0) {
		if (in) {
			bcopy(w, bb, 8);
			bb += 8;
			len -= 8;
			out += 8;
		} 
		else return(0);
		if ((in = fread(bb, 1, len, ff))) {
			for (block = 0; block < in / 8; block++) {
				if (des_type == CBC) dedes_cbc(bb);
				else dedes_ecb(bb);
				bb += 8;
				out += 8;
			}
		}
		if (in < len || ((in = fread(w, 1, 8, ff)) != 8)) {
			rest = *(bb - 1);
			if (rest < 0 || rest > 7) {
				aux_add_error(EINVALID, "DES decryption error: wrong bytecount", 0, 0, proc);
				return(-1);
			}
			out -= (8 - rest);
			in = 0;
			return(out);
		}
		if (des_type == CBC) dedes_cbc(w);
		else dedes_ecb(w);
		return(out);
	}

	while (1) {
		if (wout) {
			if (len < wout) {
				bcopy(ww, bb, len);
				ww += len;
				wout -= len;
				out += len;
				return(out);
			}
			bcopy(ww, bb, wout);
			len -= wout;
			out += wout;
			bb += wout;
			wout = 0;
			if (w == &work[0]) {
				w = nwork;
				nw = work;
			} 
			else {
				w = work;
				nw = nwork;
			}
		}
		if (len == 0 || in == 0) return(out);
		if ((in = fread(nw, 1, 8, ff))) {
			if (des_type == CBC) dedes_cbc(nw);
			else dedes_ecb(nw);
		}
		ww = w;
		if (in == 8) wout = 8;
		else wout = w[7];
		if (wout == 0) return(out);
	}
}


write_enc(fd, buf, len, key)
int	fd, len;
char	*buf, *key;
{
	Key deskey;
	static int	first = TRUE;
	static FILE *ff;
	static char	work[8];
	static char	*w;
	static int	des_type, wout;
	int	out = 0;
	AlgMode algmode;
	register int	block;
	register char	*bb;
	int	i;
	char	*proc = "write_enc";

	if (!buf && first == FALSE) {
		work[7] = wout;
		if (des_type == CBC) endes_cbc(work);
		else endes_ecb(work);
		fwrite(work, 1, 8, ff);
		fclose(ff);
		c_desdone(FALSE);
		first = TRUE;
		return(0);
	}

	if (!len) return(0);

	if (!key || !strlen(key)) return(write(fd, buf, len));

	if (first) {
		deskey.keyref = 0;
		deskey.pse_sel = (PSESel * )0;
		if (sec_string_to_key(key, &deskey) < 0) {
			aux_add_error(EINVALID, "sec_string_to_key failed", 0, 0, proc);
			return(-1);
		}

		algmode = aux_ObjId2AlgMode(deskey.key->subjectAI->objid);
		if (algmode == CBC) des_type = CBC;
		else des_type = ECB;

                des3 = FALSE;

		if (desfirst(deskey.key, des_type) < 0) {
			aux_free_KeyInfo(&(deskey.key));
			aux_add_error(EINVALID, "desfirst failed", 0, 0, proc);
			return(-1);
		}

		aux_free_KeyInfo(&(deskey.key));
		if (!(ff = fdopen(fd, "w"))) {
			aux_add_error(ESYSTEM, "fdopen failed", 0, 0, proc);
			return(-1);
		}

		w = work;
		wout = 0;
		first = FALSE;
	}

	bb = buf;
	if (wout == 0 && len > 8) {
		for (block = 0; block < len / 8; block++) {
			if (des_type == CBC) endes_cbc(bb);
			else endes_ecb(bb);
			bb += 8;
		}
		out = bb - buf;
		fwrite(buf, 1, out, ff);
		len -= out;
	}
	while (len) {
		*w++ = *bb++;
		wout++;
		out++;
		if (wout == 8) {
			if (des_type == CBC) endes_cbc(work);
			else endes_ecb(work);
			fwrite(work, 1, 8, ff);
			wout = 0;
			w = work;
		}
		len--;
	}
	return(out);
}


close_dec(fd)
int	fd;
{
	read_dec(fd, CNULL, 0, CNULL);
	close(fd);

	return(0);
}


close_enc(fd)
int	fd;
{
	write_enc(fd, CNULL, 0, CNULL);
	close(fd);

	return(0);
}


c_desdone(des3)
Boolean des3; 
{

        desdone(des3);
        DESINIT = FALSE;

	return(0);
}


/* This is supposed to be a one-way string-to-key function. */

char	*string_to_key(asckey)
char	*asckey;
{
	register char	*p;
	register int	i;
	char	k1[8], k2[8];
	char	*key;
	char	*proc = "string_to_key";

	if (!(key = (char *)malloc(8))) {
		aux_add_error(EMALLOC, "key", 0, 0, proc);
		return(CNULL);
	}
	if (DESINIT == FALSE) {
		if (desinit(0, FALSE) < 0) {
			aux_add_error(EINVALID, "desinit failed", 0, 0, proc);
			free(key);
			return(CNULL);
		}

		DESINIT = TRUE;
	}

	for (i = 0; i < 8; i++) {
		k1[i] = k2[i] = 0;
	}
	for (i = 0, p = asckey; *p; p++, i++) {
		i %= 8;
		k1[i] |= *p;
		k2[i] |= *p;
		setkey(des_hash_key1);
		endes(k1);
		setkey(des_hash_key2);
		endes(k2);
	}
	for (i = 0; i < 8; i++) {
		key[i] = k1[i] ^ k2[i];
	}
	return(key);
}