misc.c

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

/*******************************************************************
*
*      Copyright (c) 1994-1999 Jetico, Inc., Finland
*      All rights reserved.
*
*      File: bccreate.c
*      Revision:    $Id: misc.c,v 1.36 2005/05/14 12:07:03 crypt Rel-1.6-3 $
*      Created:
*      Description: implementation of miscelleneous routines
*
*******************************************************************/



#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <unistd.h>
#include <ctype.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <fcntl.h>
#include <string.h>
#include <signal.h>
#include <stdarg.h>
#include <pwd.h>
#include <grp.h>
#include <assert.h>
#include <bc_types.h>
#include <bc_ioctl.h>
#include "keygen.h"
#include <kg_defs.h>
#include <fcntl.h>
//#include <kblock.h>
#include "header.h"
#include "alg.h"
#include "config.h"
#include "error.h"
#include "fstypes.h"
#include "misc.h"
#include "version.h"
#include <dlfcn.h>


char misc_c[]="$Id: misc.c,v 1.36 2005/05/14 12:07:03 crypt Rel-1.6-3 $";

#define MAX_DEVICES 16


char _device[MAX_DEV_PATH];

void SetSignalHandlers(void (*handler)(int))
{

    signal(SIGINT,handler);
    signal(SIGQUIT,handler);
    signal(SIGTERM,handler);
    signal(SIGABRT,handler);

}



char* strtolower(char *string)
{
    size_t i;
    for ( i=0;i<=strlen(string);i++ )string[i]=tolower(string[i]);
    return string;

}


void msg(FILE *fd, const char *format, ... )
{

    va_list args;

    va_start(args, format);
    vfprintf(fd, format, args);
    va_end(args);                                                                                                   

}

int is_valid_container(char *filename)
{

    struct HiddenSector  hs;
    int fd;


    if ( (fd = open(filename, O_RDONLY|O_LARGEFILE)) < 0 )
    {
        msg(stderr,"%s: %s\n",filename,strerror(errno));
        return FALSE;
    }
    if ( read(fd, &hs, sizeof(hs))!=sizeof(hs) )
    {
        msg(stderr,"read(\"%s\",&hs,sizeof(hs): %s\n",filename,strerror(errno));
        close(fd);
        return FALSE;
    }

    close(fd);

    if ( strncmp(hs.br.OEMid, "LOCOS94 ", sizeof(hs.br.OEMid))!=0 )
    {
        return FALSE;
    }

    if ( strncmp(hs.br.volumeLabel, "CRYPTED_DSK", sizeof(hs.br.volumeLabel))!=0 )
    {
        return FALSE;
    }

    return TRUE;

};




long long string_to_long(char *string)
{

    char *endptr;
    long long result;

    result=strtoul(string,&endptr,0);
    if ( string==endptr ) return 0;
    if ( (string[0]!='\0')&&(endptr[0]=='\0') ) return result;
    if ( (endptr[0]=='K' || endptr[0]=='k' )&&(endptr[1]=='\0') )
    {
        result *=1024;
        return result;
    };
    if ( (endptr[0]=='M' || endptr[0]=='m')&&(endptr[1]=='\0') )
    {
        result *=1024*1024;
        return result;
    };
    if ( (endptr[0]=='G' || endptr[0]=='g')&&(endptr[1]=='\0') )
    {
        result *=1024*1024*1024;
        return result;
    };
    return 0L;

}



int open_bc_dev(char *dev, int d)
{
    int fd;
    snprintf(dev,MAX_DEV_PATH,"/dev/bcrypt/disc%d/disc",d);
    if ( (fd = open(dev, O_RDONLY)) < 0 )
    {
        snprintf(dev,MAX_DEV_PATH,"/dev/bcrypt%d",d);
        fd = open(dev, O_RDONLY);
    }
    return fd;
}



char* FindFreeDevice()
{

    int i,n,rc;
    ALG_SERV Alg;

    for ( i=0;i<MAX_DEVICES;i++ )
    {
        Alg.bc_fd = open_bc_dev(_device, i);
        if ( Alg.bc_fd >= 0 )
        {
            rc=bc_get_info(Alg,&n,&n);
            close(Alg.bc_fd);
            if ( rc==0 ) return _device;
        }
    }

    return NULL;
}


char* FindMountedDevice(char *arg)
{

    struct stat buff1;
    int i;
    dev_t dev;

    if ( lstat(arg,&buff1)!=0 ) return NULL;
    if ( S_ISBLK(buff1.st_mode) ) return arg;
    dev=buff1.st_dev;

    for ( i=0;i<MAX_DEVICES;i++ )
    {
        snprintf(_device,MAX_DEV_PATH,"/dev/bcrypt/disc%d/disc",i);
        if ( lstat(_device,&buff1)==0 && dev==buff1.st_rdev ) return _device;
        snprintf(_device,MAX_DEV_PATH,"/dev/bcrypt%d",i);
        if ( lstat(_device,&buff1)==0 && dev==buff1.st_rdev ) return _device;
    }

    return NULL;
}


int IsOwner(uid_t uid, char *arg)
{

    struct stat buff;

    if ( lstat(arg,&buff)!=0 ) return -1;
    if ( buff.st_uid==uid ) return TRUE;
    return FALSE;

}   


int run_process(char *args[])
{
    int pid;
    char *env[] = { "PATH=/sbin", NULL};

    assert(args != NULL);
    assert(args[0] != NULL);

    pid = fork();
    if ( pid < 0 )
    {
        msg(stderr,"fork: %s\n", strerror(errno));
        return -1;
    }

    if ( pid == 0 )
    { /* Child */

        execve(args[0], args, env);
        msg(stderr,"execve %s failed: %s\n", args[0], strerror(errno));
    }

    /* Parent. */
    wait(NULL);
    return 0;
}

//ask_y_n(char *string)
//asks for yes or no
//return value:
//TRUE if 'y' entered
//FALSE in other cases
int ask_y_n(char *string)
{
    char c;
    msg(stderr,string);
    c = tolower(fgetc(stdin));
    if ( '\n' == c ) return FALSE;
    while ( '\n' != fgetc(stdin) );
    if ( 'y' == c ) return TRUE;
    return FALSE;
}

int get_uid_by_name(const char *name)
{
    struct passwd *pass;
    if ( NULL == name )
        return -1;
    pass=getpwnam(name);
    if ( NULL == pass )
        return -1;
    return pass->pw_uid;
}
int get_gid_by_name(const char *name)
{
    struct group *grp;
    if ( NULL == name )
        return -1;
    grp=getgrnam(name);
    if ( NULL == grp )
        return -1;
    return grp->gr_gid;

}


char* getFStypeById(unsigned int id)
{

    if ( id > MAX_ID )return NULL;
    return fstypes[id];
}

int   getIdByFStype(char *fstype)
{

    int i;

    for ( i=0;i<MAX_ID;i++ )if ( strcmp(fstype,fstypes[i])==0 ) return i;
    return MAX_ID + 1;

}

int modules_loaded()
{
    int major,minor;
    ALG_SERV Alg;
    char device[MAX_DEV_PATH];
    
    Alg.bc_fd = open_bc_dev(device, 0);

    if ( ENODEV == errno || 0 >  bc_get_info(Alg,&major,&minor) )
    {
        close(Alg.bc_fd);
        msg(stderr,"Kernel modules not loaded\n");
        return FALSE;
    }
    close(Alg.bc_fd);

    if (major != VERSION_MAJOR || minor != VERSION_MINOR)
    {
        msg(stderr,"One or more components of BestCrypt outdated.\n"
                   "driver version %d.%d\n"
                   "bctool version %d.%d\n"
                   "Please update your current version of BestCrypt\n",
            major,minor,VERSION_MAJOR,VERSION_MINOR);
        
        return FALSE;
    }

    return TRUE;
}


int lock_container(char *name)
{
    struct HiddenSector hs;
    int fd,len;

    if ( -1 == (fd  = open(name,O_RDWR|O_LARGEFILE)) )
    {
        return -1;   
    }
    len = read(fd,&hs,sizeof(hs)); 
    if ( -1 == len )
    {
        len = errno;
        close(fd);
        errno = len;
        return -1;
    }

    if ( lseek(fd,0,SEEK_SET) < 0 )
    {
        len = errno;