des_if.c

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

/*
 *  SecuDE Release 4.1 (GMD)
 */
/********************************************************************
 * Copyright (C) 1991, GMD. All rights reserved.                    *
 *                                                                  *
 *                                                                  *
 *                         NOTICE                                   *
 *                                                                  *
 *    Acquisition, use, and distribution of this module             *
 *    and related materials are subject to restrictions             *
 *    mentioned in each volume of the documentation.                *
 *                                                                  *
 ********************************************************************/

/*
 *  DES interface module between sec_encrypt/sec_decrypt
 *  and Phil Karn's DES package
 *
 *  WS 6.12.90
 *
 *  Last change: 7.12.90
 *
 *  Imports from Karn's:
 *
 *  desinit(mode) int mode;
 *  setkey(key) char *key;
 *  endes(block) char *block;
 *  dedes(block) char *block;
 *  desdone()
 *
 *  Exports to libdes.a:
 *
 *  des_encrypt(in_octets, out_bits, more, keyinfo)
 *  des_decrypt(in_bits, out_octets, more, keyinfo)
 *  read_dec(fd, buf, len, pin)
 *  write_enc(fd, buf, len, pin)
 *  string_to_key(pin) 
 *
 */

#define STD 0
#define PEM 1
#define RAW 2

#include "secure.h"
#include <stdio.h>
#include <fcntl.h>

#ifdef MAC
#include <Unix.h>
#include <stdlib.h>
#include <string.h>
#include "Mac.h"
#endif /* MAC */

static char	iv[8];  /* Initialization vector */
static int	DESINIT = FALSE;
static char     des3;
static unsigned char	des_hash_key1[8] = 
{ 
	0x9a, 0xd3, 0xbc, 0x24, 0x10, 0xe2, 0x8f, 0x0e };


static unsigned char	des_hash_key2[8] = 
{ 
	0xe2, 0x95, 0x14, 0x33, 0x59, 0xc3, 0xec, 0xa8 };

void endes_cbc(), endes_ecb(), dedes_cbc(), dedes_ecb();
static desfirst();

des_encrypt(in_octets, out_bits, more, keyinfo)
OctetString *in_octets;
BitString *out_bits;
More more;
KeyInfo *keyinfo;
{
	static int	first = TRUE, des_type, padding;
        AlgEnc   algenc;
	AlgMode  algmode;
        AlgSpecial algspecial;
	static unsigned int	remaining_octets;
	static char	remaining_buf[8];

	register int	encrypted_blocks, octets_to_be_encrypted, encrypted_octets;
	register char	*inp, *outp;
	register int	i;
	unsigned int	remaining_octets_new;
	char	*proc = "des_encrypt";

	if (first) {
                algenc = aux_ObjId2AlgEnc(keyinfo->subjectAI->objid);
                algmode = aux_ObjId2AlgMode(keyinfo->subjectAI->objid);
                algspecial = aux_ObjId2AlgSpecial(keyinfo->subjectAI->objid);

                if(algenc == DES3) des3 = TRUE;
                else des3 = FALSE;

		if (algmode == CBC) des_type = CBC;
		else des_type = ECB;

		padding = RAW;
		if (algspecial == WITH_PEM_PADDING) padding = PEM;
		if (algspecial == WITH_PADDING)	padding = STD;

		remaining_octets = 0;
		if (desfirst(keyinfo, des_type) < 0) {
			aux_add_error(EINVALID, "desfirst failed", 0, 0, proc);
			return(-1);
		}
		first = FALSE;
	}
	if (more == END) first = TRUE;

	octets_to_be_encrypted = in_octets->noctets;
	inp = in_octets->octets;
	outp = out_bits->bits + (out_bits->nbits / 8);

	encrypted_octets = 0;

	if (remaining_octets) {

		for (i = remaining_octets; i < 8; i++) {
			if (octets_to_be_encrypted - 1 >= 0) {
				remaining_buf[i] = *inp++;
				octets_to_be_encrypted--;
				remaining_octets++;
			} else break;
		}
		if (i == 8) {
			bcopy(remaining_buf, outp, 8);
			if (des_type == CBC) 
                                endes_cbc(outp);
			else 
				endes_ecb(outp);
			outp += 8;
			encrypted_octets = 8;
			remaining_octets = 0;
		}

	}

	encrypted_blocks = octets_to_be_encrypted / 8;
	remaining_octets_new = octets_to_be_encrypted % 8;

	if (encrypted_blocks) {
		octets_to_be_encrypted = encrypted_blocks * 8;
		if (inp != outp) 
			bcopy(inp, outp, octets_to_be_encrypted);
		for (i = 0; i < encrypted_blocks; i++) {
			if (des_type == CBC) 
				endes_cbc(outp);
			else 
				endes_ecb(outp);
			inp += 8;
			outp += 8;
		}
		encrypted_octets += octets_to_be_encrypted;
	}

	out_bits->nbits += (encrypted_octets * 8);

	if (remaining_octets_new) {
		for (i = remaining_octets; i < remaining_octets + remaining_octets_new; i++) 
			remaining_buf[i] = *inp++;
		remaining_octets += remaining_octets_new;
	}

	if (more == END) {
		switch (padding) {
		case STD:
			remaining_buf[7] = remaining_octets;
			bcopy(remaining_buf, outp, 8);
			if (des_type == CBC) 
				endes_cbc(outp);
			else 
				endes_ecb(outp);
			encrypted_octets += 8;
			out_bits->nbits += 64;
			break;
		case PEM:
			for (i = remaining_octets; i < 8; i++) 
				remaining_buf[i] = 8 - remaining_octets;
			bcopy(remaining_buf, outp, 8);
			if (des_type == CBC) 
				endes_cbc(outp);
			else 
				endes_ecb(outp);
			encrypted_octets += 8;
			out_bits->nbits += 64;
			break;
		case RAW:
			if (remaining_octets == 0) 
				break;
			for (i = remaining_octets; i < 8; i++) 
				remaining_buf[i] = 0;
			bcopy(remaining_buf, outp, 8);
			if (des_type == CBC) 
				endes_cbc(outp);
			else 
				endes_ecb(outp);
			encrypted_octets += 8;
			out_bits->nbits += 64;
			break;
		}
		c_desdone(des3);
	}

	return(encrypted_octets * 8);
}


void
endes_cbc(outblock)
char	*outblock;
{
	register char	*cp, *cp1;
	register int	i;

	/* CBC mode; chain in last cipher word */

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

	endes_ecb(outblock);	/* in-block encryption */

	/* Save outblockgoing ciphertext for chain */

	bcopy(outblock, iv, 8);
}

void
endes_ecb(outblock)
char	*outblock;
{
        if(des3) {
                endes(outblock);
                dedes1(outblock);
                endes(outblock);
        }
        else endes(outblock);
        return;
}

des_decrypt(in_bits, out_octets, more, keyinfo)
BitString *in_bits;
OctetString *out_octets;
More more;
KeyInfo *keyinfo;
{
	static int	first = TRUE, des_type, padding;
        AlgEnc   algenc;
        AlgMode  algmode;
        AlgSpecial  algspecial;
	static unsigned int	remaining_bits, remaining_octets;
	static unsigned char	remaining_buf[8];

	register int	decrypted_blocks, octets_to_be_decrypted, bits_to_be_decrypted, decrypted_octets;
	register char	*inp, *outp;
	register int	i;
	unsigned int	remaining_bits_new, remaining_octets_new;
	char	*proc = "des_decrypt";

	if (first) {
                algenc = aux_ObjId2AlgEnc(keyinfo->subjectAI->objid);
                algmode = aux_ObjId2AlgMode(keyinfo->subjectAI->objid);
                algspecial = aux_ObjId2AlgSpecial(keyinfo->subjectAI->objid);

                if(algenc == DES3) des3 = TRUE;
                else des3 = FALSE;

		if (algmode == CBC) des_type = CBC;
		else des_type = ECB;

		padding = RAW;
		if (algspecial == WITH_PEM_PADDING) padding = PEM;
		if (algspecial == WITH_PADDING)	padding = STD;

		remaining_bits = 0;
		remaining_octets = 0;
		if (desfirst(keyinfo, des_type) < 0) {
			aux_add_error(EINVALID, "desfirst failed", 0, 0, proc);
			return(-1);
		}
		first = FALSE;
	}
	if (more == END) first = TRUE;

	bits_to_be_decrypted = in_bits->nbits;
	inp = in_bits->bits;
	outp = out_octets->octets + out_octets->noctets;

	decrypted_octets = 0;

	if (remaining_bits) {

		/* This works only if remaining_bits is a multiple of 8.
                   Major stuff must be inserted here to handle arbitrary in_bits->nbits  */

		for (i = remaining_octets; i < 8; i++) {
			if (bits_to_be_decrypted - 8 >= 0) {
				remaining_buf[i] = *inp++;
				bits_to_be_decrypted -= 8;
				remaining_bits += 8;
				remaining_octets++;
			} else 
				break;
		}
		if (i == 8) {
			bcopy(remaining_buf, outp, 8);
			if (des_type == CBC) 
				dedes_cbc(outp);
			else 
				dedes_ecb(outp);
			outp += 8;
			decrypted_octets = 8;
			remaining_octets = 0;
			remaining_bits = 0;
		}

	}

	decrypted_blocks = bits_to_be_decrypted / 64;
	remaining_bits_new = bits_to_be_decrypted % 64;
	if (decrypted_blocks) {
		octets_to_be_decrypted = decrypted_blocks * 8;
		if (inp != outp) 
			bcopy(inp, outp, octets_to_be_decrypted);
		for (i = 0; i < decrypted_blocks; i++) {
			if (des_type == CBC) 
				dedes_cbc(outp);
			else 
				dedes_ecb(outp);
			inp += 8;
			outp += 8;
		}
		decrypted_octets += octets_to_be_decrypted;
	}

	out_octets->noctets += decrypted_octets;

	if (remaining_bits_new) {
		if (more == END) {
			aux_add_error(EINVALID, "input not multiple of eight", 0, 0, proc);
			return(-1);
		}
		remaining_octets_new = remaining_bits_new / 8;
		if (remaining_bits_new % 8) 
			remaining_octets_new++;
		for (i = remaining_octets; i < remaining_octets + remaining_octets_new; i++) 
			remaining_buf[i] = *inp++;
		remaining_octets += remaining_octets_new;
		remaining_bits += remaining_bits_new;
	}

	if (more == END) {
		c_desdone(des3);
		switch (padding) {
		case STD:
			outp--;
			i = *outp;
			if (i < 0 || i > 7) {
				aux_add_error(EDECRYPT, "wrong bytecount (STD)", 0, 0, proc);
				return(-1);
			}
			i = 8 - i;
			out_octets->noctets -= i;
			decrypted_octets -= i;
			break;
		case PEM:
			outp--;
			i = *outp;
			if (i <= 0 || i > 8) {
				aux_add_error(EDECRYPT, "wrong bytecount (PEM)", 0, 0, proc);
				return(-1);
			}
			out_octets->noctets -= i;
			decrypted_octets -= i;
			break;