alg.c

加密解密,安全工具！很有意思的代码

/*******************************************************************
 *	Copyright (c) 1994-1999 Jetico, Inc., Finland
 *	All rights reserved.
 *
 *	File: alg.c
 *	Created:
 *	Revision: $Id: alg.c,v 1.11 2004/12/16 08:42:35 nail Rel-1.6-3 $
 *
 *	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_c[]="$Id: alg.c,v 1.11 2004/12/16 08:42:35 nail Rel-1.6-3 $";

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)
{
    int res;
    if ( Alg.bc_fd < 0 ) return -EINVAL;
    res = ioctl(Alg.bc_fd, BC_CLR_FD, 0);
    return res;
}

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;
        rc=arg.busy;
        return rc;  
    }   
}

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);
}