alg.cpp

BestCrypt开源加密原代码

/*******************************************************************
*
*      Copyright (c) 1994-1999 Jetico, Inc., Finland
*      All rights reserved.
*
*      File: alg.cc
*      Revision:  $Id: alg.cpp,v 1.1 2005/05/12 09:51:39 crypt Rel-1.6-5 $
*      Created:
*      Description: IOCTL wrappers for BestCrypt Driver.
*
*******************************************************************/
	    
#include <sys/ioctl.h>
#include <errno.h>
#include <string.h>

#include <bc_types.h>
#include "alg.h"

char alg_cpp[]="$Id: alg.cpp,v 1.1 2005/05/12 09:51:39 crypt Rel-1.6-5 $";


int alg_verify		(ALG_SERV Alg)
{
	struct bc_alg arg;
	int i, rc;

	if (Alg.bc_fd < 0) return -EINVAL;
	if (!Alg.alg_module) return -EINVAL;
	
	arg.magic = BC_MAGIC;
	arg.error = 0;
	arg.alg_id = Alg.alg_id;
	rc = strlen(Alg.alg_module) + 1;
	if (rc > MOD_NAME_LEN) rc = MOD_NAME_LEN;
	for (i = 0; i < rc; i++)
        	arg.alg_module[i] = *Alg.alg_module++;
    	arg.alg_module[i] = 0;
	
	rc = ioctl(Alg.bc_fd, BC_VERIFY_ALG, &arg);
	if (rc < 0) return rc;	/* fatal error, must be < 0 */
	else if (arg.magic != BC_MAGIC) return -1; /* ?? */
	else return arg.error;	/* internal status or warning >= 0 */
}

int alg_make_key	(ALG_SERV Alg,
			BYTE *key, 
			DWORD key_len, /* bits */
			BYTE *pool,
			KEY_HANDLE *key_handle)
{
	struct bc_key arg;
	int i, rc;

	if (Alg.bc_fd < 0) return -EINVAL;
/* not arbitrary */
/*	if (!Alg.alg_module) return -EINVAL; */
	if (!key) return -EINVAL;
	if (!pool) return -EINVAL;
	if (!key_handle) return -EINVAL;

	arg.magic = BC_MAGIC;
	arg.error = 0;
	arg.alg_id = Alg.alg_id;

	rc = strlen(Alg.alg_module) + 1;
	if (rc > MOD_NAME_LEN) rc = MOD_NAME_LEN;
	for (i = 0; i < rc; i++)
        	arg.alg_module[i] = *Alg.alg_module++;
    	arg.alg_module[i] = 0;

	arg.key = key;
	arg.key_len = key_len;
	arg.pool = pool;
	arg.key_handle = 0xFFFFFFFF;
	
	rc = ioctl(Alg.bc_fd, BC_MAKE_KEY, &arg);
	if (rc < 0) return rc;	/* fatal error, must be < 0 */
	else if (arg.magic != BC_MAGIC) return -1; /* ?? */
	else { 
		*key_handle = arg.key_handle;
		return arg.error;	/* internal status or warning >= 0 */
	}
}

int alg_free_key	(ALG_SERV Alg, KEY_HANDLE key_handle)
{
	struct bc_key arg;
	int rc;

	if (Alg.bc_fd < 0) return -EINVAL;
	memset(&arg, 0, sizeof(struct bc_key));
	arg.magic = BC_MAGIC;
	arg.error = 0;
	arg.alg_id = Alg.alg_id;
	arg.key_handle = key_handle;
	
	rc = ioctl(Alg.bc_fd, BC_FREE_KEY, &arg);
	if (rc < 0) return rc;	/* fatal error, must be < 0 */
	else if (arg.magic != BC_MAGIC) return -1; /* ?? */
	else return arg.error;	/* internal status or warning >= 0 */
}
			
static int alg_process	(int bc_fd, DWORD alg_id,
				KEY_HANDLE key_handle,
				BYTE *iv,
				BYTE *buffer,
				DWORD buffer_len,
				int request)
{
	struct bc_block arg;
	int rc, i;

	if (bc_fd < 0) return -EINVAL;
	if (!iv) return -EINVAL;
	if (!buffer) return -EINVAL;
	if (buffer_len > MAX_BLOCK_SIZE) return -EINVAL;

	arg.magic = BC_MAGIC;
	arg.error = 0;
	arg.alg_id = alg_id;
	arg.key_handle = key_handle;
	for (i = 0; i < 8; i++) arg.iv[i] = iv[i];
	arg.buffer = buffer;
	arg.buffer_len = buffer_len;
		
	rc = ioctl(bc_fd, request, &arg);
	if (rc < 0) return rc;	/* fatal error, must be < 0 */
	else if (arg.magic != BC_MAGIC) return -1; /* ?? */
	else return arg.error;	/* internal status or warning >= 0 */
}
							
int alg_encrypt	(		ALG_SERV Alg,
				KEY_HANDLE key_handle,
				BYTE *iv,
				BYTE *buffer,
				DWORD buffer_len)
{
	return alg_process(Alg.bc_fd, Alg.alg_id, 
				key_handle, 
				iv, 
				buffer, 
				buffer_len,
				BC_ENCRYPT_BLOCK);
}
				
int alg_decrypt	(		ALG_SERV Alg,
				KEY_HANDLE key_handle,
				BYTE *iv,
				BYTE *buffer,
				DWORD buffer_len)
{
	return alg_process(Alg.bc_fd, Alg.alg_id, 
				key_handle, 
				iv, 
				buffer, 
				buffer_len,
				BC_DECRYPT_BLOCK);
}
/*
int bc_set_fd64	(		ALG_SERV Alg,
				BYTE *key, 
				DWORD key_len, // bits 
				BYTE *pool,
				int fd,
				unsigned long long offset,
				unsigned int flags)
{
	struct bc_key		arg1;
	struct bc_file64	arg2; 
	KEY_HANDLE	kh;
	int i, rc;
	

	if (Alg.bc_fd < 0) return -EINVAL;
// not arbitrary 
//	if (!Alg.alg_module) return -EINVAL; 
	if (!key) return -EINVAL;
	if (!pool) return -EINVAL;
	if (offset < 0) return -EINVAL;
	if (fd < 0) return -EINVAL;

	arg1.magic	= BC_MAGIC;
	arg1.error	= 0;
	arg1.alg_id	= Alg.alg_id;

	rc = strlen(Alg.alg_module) + 1;
	if (rc > MOD_NAME_LEN) rc = MOD_NAME_LEN;
	for (i = 0; i < rc; i++)
        	arg1.alg_module[i] = *Alg.alg_module++;
    	arg1.alg_module[i] = 0;

	arg1.key	= key;
	arg1.key_len	= key_len;
	arg1.pool	= pool;
	arg1.key_handle	= 0xFFFFFFFF;
	
	rc = ioctl(Alg.bc_fd, BC_MAKE_KEY, &arg1);
	if (rc < 0) return rc;	// fatal error, must be < 0 
	else if (arg1.magic != BC_MAGIC) return -1; // ?? 
	else kh = arg1.key_handle;

	memset(&arg2, 0, sizeof(arg2));	
	arg2.magic	= BC_MAGIC;
	arg2.fd		= fd;
	arg2.offset	= offset;
	arg2.key_handle	= kh;
	arg2.alg_id	= Alg.alg_id;
	arg2.flags	= flags;
	
	rc = ioctl(Alg.bc_fd, BC_SET_FD, &arg2);
	if (rc < 0) return rc;	// fatal error, must be < 0 
	else if (arg2.magic != BC_MAGIC) return -1; // ?? 
	else return arg2.error;
}

int bc_set_fdkh64	(	ALG_SERV Alg,
				KEY_HANDLE kh,
				int fd,
				unsigned long long offset,
				unsigned long long start_sector,
				unsigned long long num_sectors,
				unsigned int flags)
{
	struct bc_file64	arg2; 
	int rc;
	

	if (Alg.bc_fd < 0) return -EINVAL;
// not arbitrary
//	if (!Alg.alg_module) return -EINVAL; 
	if (offset < 0) return -EINVAL;
	if (fd < 0) return -EINVAL;

	memset(&arg2, 0, sizeof(arg2));	
	arg2.magic	= BC_MAGIC;
	arg2.fd		= fd;
	arg2.offset	= offset;
	arg2.key_handle	= kh;
	arg2.alg_id	= Alg.alg_id;
	arg2.flags	= flags;
	arg2.start_sector = start_sector;
	arg2.num_sectors  = num_sectors;
	
	rc = ioctl(Alg.bc_fd, BC_SET_FD, &arg2);
	if (rc < 0) return rc;	// fatal error, must be < 0 
	else if (arg2.magic != BC_MAGIC) return -1; // ?? 
	else return arg2.error;
}
				
int bc_clear_fd		(ALG_SERV Alg)
{
	if (Alg.bc_fd < 0) return -EINVAL;
	return ioctl(Alg.bc_fd, BC_CLR_FD, 0);
}

int bc_get_info		(ALG_SERV Alg, int *ver_major, int *ver_minor)
{
	struct bc_info	arg;
	int rc;
	
	if (Alg.bc_fd < 0) return -EINVAL;
	memset(&arg, 0, sizeof(struct bc_info));
	arg.magic = BC_MAGIC;
	rc = ioctl(Alg.bc_fd, BC_GET_INFO, &arg);
	if (rc < 0) return rc;	// fatal error, must be < 0
	else if (arg.magic != BC_MAGIC) return -1; // ?? 
	else {
		if (ver_major) *ver_major = arg.ver_major;
		if (ver_minor) *ver_minor = arg.ver_minor;
		return arg.busy;
	}
}

int bc_lock_dev		(ALG_SERV Alg)
{
	if (Alg.bc_fd < 0) return -EINVAL;
	return ioctl(Alg.bc_fd, BC_LOCK_DEV, 0);
}

int bc_unlock_dev	(ALG_SERV Alg)
{	
        if (Alg.bc_fd < 0) return -EINVAL;
	return ioctl(Alg.bc_fd, BC_UNLOCK_DEV, 0);
}

int bc_get_priv(ALG_SERV Alg, unsigned long drop_pid) 
{
        if (Alg.bc_fd < 0) return -EINVAL;
	return ioctl(Alg.bc_fd, BC_GET_PRIV, drop_pid);
}

int bc_force_unlock(ALG_SERV Alg)
{	
        if (Alg.bc_fd < 0) return -EINVAL;
	return ioctl(Alg.bc_fd, BC_FORCE_UNLOCK, 0);
}

int bc_check_activity(ALG_SERV Alg, long *result)
{	
        if (Alg.bc_fd < 0 || NULL == result) 
		return -EINVAL;
	return ioctl(Alg.bc_fd, BC_CHECK_ACTIVITY, result);
}
*/