main.c

加解密包

#include "config.h"

#include <stdio.h>
#ifdef HAVE_STRINGS_H
#include <strings.h>
#endif
#ifdef HAVE_STRING_H
#include <string.h>
#endif

#include "EDtk.h"

int ERR_print_errors_fp(FILE *);

#define SIZE 8192
char buf_pub[SIZE];
char buf_priv[SIZE];
char buf_text[SIZE];
char buf_output[SIZE];

int main(int argc, char *argv[])
{
  int len_pub,len_priv,len_text,len_output;
  FILE *f;
  len_output=SIZE;
  
  EDtkInit();
  f=fopen(argv[2],"r");
  if (f==NULL) {
    perror("fopen");
    return 1;
  }
  len_pub=fread(buf_pub,1,SIZE,f);
  fclose(f);
  f=fopen(argv[3],"rb");
  if (f==NULL) {
    perror("fopen");
    return 1;
  }
  len_priv=fread(buf_priv,1,SIZE,f);
  fclose(f);
  f=fopen(argv[4],"rb");
  if (f==NULL) {
    perror("fopen");
    return 1;
  }
  len_text=fread(buf_text,1,SIZE,f);
  fclose(f);
  
  switch (argv[1][0]) {
  case 'e':
    if (EDtkEncrypt(buf_text,len_text,buf_output,&len_output,buf_pub,len_pub,buf_priv,len_priv,argv[5])==0) {
      /*
      unsigned long err;
      err=ERR_get_error();
      fprintf(stderr,"r=%s\n", ERR_reason_error_string( err));
      */
      ERR_print_errors_fp(stderr);
    } else {
      f=fopen("encode.bin","wb");
      fwrite(buf_output,len_output,1,f);
      fclose(f);
    }
    break;
  case 'd':
    if (EDtkDecrypt(buf_text,len_text,buf_output,&len_output,buf_pub,len_pub,buf_priv,len_priv,argv[5])==0) {
      ERR_print_errors_fp(stderr);
    } else {
      fwrite(buf_output,len_output,1,stdout);
    }
    break;
  case 'k':
    if (EDtkVerifyPrivateKey(buf_priv,len_priv,argv[5])==0) {
      fprintf(stderr,"Bad password %s for private key %s.\n", argv[5],argv[3]);
    } else {
      fprintf(stderr,"Good password %s for private key %s.\n", argv[5],argv[3]);
    }
    break;
  case 'c':
    {
      unsigned char *buf=0;
      int len;
      if (EDtkChangePassword(buf_priv,len_priv,argv[5],"ABCD",&buf,&len)==0) {
        ERR_print_errors_fp(stderr);
      } else {
        fwrite(buf,len,1,stdout);
        if (EDtkVerifyPrivateKey(buf,len,"ABCD")==0) {
          ERR_print_errors_fp(stderr);
        } else {
          fprintf(stderr,"Good password for private key.\n");
        }
      }
      if (buf) {
        EDtkFree(buf);
      }
    }
    break;
  case 'b':
    {
      char *buf=0;
      int len;
      unsigned char *bbuf=0;
      int blen;
      if (EDtkBase64Encode(buf_text,len_text,&buf,&len)==0) {
        ERR_print_errors_fp(stderr);
      } else {
        fwrite(buf,len,1,stdout);
        if (EDtkBase64Decode(buf,len,&bbuf,&blen)==0) {
          ERR_print_errors_fp(stderr);
        } else {
          fwrite(bbuf,blen,1,stdout);
        }
      }
      if (buf) {
        EDtkFree(buf);
      }
      if (bbuf) {
        EDtkFree(bbuf);
      }
    }
    break;
  case '3':
    {
      char *buf=0;
      int len;
      unsigned char *bbuf=0;
      int blen;
      if (EDtk3DESEncrypt(buf_text,len_text,&buf,&len,argv[5])==0) {
        ERR_print_errors_fp(stderr);
      } else {
        /*fwrite(buf,len,1,stdout);*/
        if (EDtk3DESDecrypt(buf,len,&bbuf,&blen,argv[5])==0) {
          ERR_print_errors_fp(stderr);
        } else {
          fwrite(bbuf,blen,1,stdout);
        }
      }
      if (buf) {
        EDtkFree(buf);
      }
      if (bbuf) {
        EDtkFree(bbuf);
      }
    }
    break;
  case 'f':
    {
      FILE *fi;
      FILE *fo;
      fi=fopen(argv[2],"rb");
      fo=fopen(argv[4],"wb");
      if (EDtk3DESEncryptFile(fi,fo,argv[5])==0) {
        ERR_print_errors_fp(stderr);
      }
      fclose(fi);
      fclose(fo);
    }
    break;
  case 'g':
    {
      FILE *fi;
      FILE *fo;
      fi=fopen(argv[2],"rb");
      fo=fopen(argv[4],"wb");
      if (EDtk3DESDecryptFile(fi,fo,argv[5])==0) {
        ERR_print_errors_fp(stderr);
      }
      fclose(fi);
      fclose(fo);
    }
    break;
  case 't':
    {
      struct x509_st *cert;
      char *nb,*na,*subject;
      int days;
      cert=EDtkLoadCertificate(buf_pub,len_pub);
      subject=EDtkCertificateSubject(cert);
      nb=EDtkCertificateNotBefore(cert);
      na=EDtkCertificateNotAfter(cert);
      days=EDtkCertificateExpireInDays(cert);
      printf("%s: not before %s, not after %s, expire in %d days\n",
             subject, nb,na,days);
      EDtkFree(subject);
      EDtkFree(na);
      EDtkFree(nb);
      EDtkFreeCertificate(cert);
      break;
    }
  case 's':
    {
      unsigned int len;
      unsigned char md[32];
      EDtkDigestSHA1(buf_text,len_text,md,&len);
      if (EDtkSign(md,len,buf_output,&len_output,
                   buf_priv,len_priv,argv[5])==0) {
        ERR_print_errors_fp(stderr);
      } else {
        f=fopen("sign.bin","wb");
        fwrite(buf_output,len_output,1,f);
        fclose(f);
      }
    }
    break;
  case 'v':
    {
      unsigned int len;
      unsigned char md[32];
      EDtkDigestSHA1(buf_text,len_text,md,&len);
      if (EDtkVerify(md,len,buf_priv,len_priv,
                     buf_pub,len_pub)==0) {
        ERR_print_errors_fp(stderr);
        printf("Signing is corrupted!\n");
      } else {
        printf("Signing is OK!\n");
      }
    }
    break;
  case 'a':
    {
      struct x509_st *cert;
      struct x509_st *ca;
      char *subject;
      cert=EDtkLoadCertificate(buf_pub,len_pub);
      subject=EDtkCertificateSubject(cert);
      ca=EDtkLoadCertificate(buf_priv,len_priv);
      if (EDtkCertificateVerify(cert,ca)==0) {
        ERR_print_errors_fp(stderr);
        printf("%s is fake!\n",subject);
      } else {
        printf("%s is signed!\n",subject);
      }
      EDtkFree(subject);
      EDtkFreeCertificate(cert);
      EDtkFreeCertificate(ca);
    }
    break;
  case 'p': {
    unsigned char *out;
    unsigned char *salt;
    int o_len;
    char *buf=0;
    int len;
    EDtkPBEsalt(&salt);
    EDtkPBEhash(argv[5], strlen(argv[5]), salt, &out, &o_len);
    EDtkBase64Encode(out,o_len,&buf,&len);
    fwrite(buf,len,1,stdout);
    EDtkFree(out);
    EDtkFree(salt);
    EDtkFree(buf);
  }
    break;
  case 'P': {
    unsigned char *out;
    unsigned char *salt;
    int o_len;
    char *buf=0;
    int len;
    EDtkFixedsalt(&salt);
    EDtkPBEhash(argv[5], strlen(argv[5]), salt, &out, &o_len);
    EDtkBase64Encode(out,o_len,&buf,&len);
    fwrite(buf,len,1,stdout);
    EDtkFree(out);
    EDtkFree(salt);
    EDtkFree(buf);
  }
    break;
  default:
    printf("Wrong argument!\n");
    break;
  }
  EDtkFinish();
  return 0;
}