#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>
#include "epcrypto.h"

#if EPC_ENABLE

#include <openssl/evp.h>

 


int do_crypt_file(FILE *    in, 
                  FILE *    out, 
                  char *    output, 
                  int       outsize, 
                  int       do_encrypt, 
                  unsigned char * begin, 
                  unsigned char * header)

    {
    char inbuf[1024], outbuf[1024 + 8192];  /*EVP_MAX_BLOCK_LENGTH*/
    int inlen, outlen;
    int blen = 0 ;
    int outcnt = 0 ;    
    unsigned char * key = EPC_KEY ;
    unsigned char * iv  = "\0x01\0x02\0x03\0x04\0x05\0x06\0x07\0x08" ;
    EVP_CIPHER_CTX  ctx ;
    int klen ;
    int ivlen ;

    
    if (output && do_encrypt)
        return -3 ; /* not supported */
    
    /*
    printf("%d %d %d\n", EVP_MAX_IV_LENGTH, EVP_MAX_BLOCK_LENGTH, ((char*)&ctx.key_len) - ((char *)&ctx)) ;

    for (blen = 0; blen < EPC_KEYLEN;blen++)
         printf("n=%d = %x\n", blen, key[blen]) ;
    */
    
    EVP_CIPHER_CTX_init(&ctx) ;
    
    /*
    EVP_CipherInit(&ctx, EPC_CHIPER, NULL, NULL, do_encrypt);
        
    for (blen = 0; blen < sizeof(ctx);blen++)
        printf("n=%d = %x\n", blen, ((unsigned char *)(&ctx))[blen])
;

    klen = EVP_CIPHER_CTX_key_length(&ctx) ;
    ivlen = EVP_CIPHER_CTX_iv_length(&ctx) ;
        
    printf ("1 chiper=%s klen=%d ivlen=%d\n",
    EVP_CIPHER_CTX_cipher(&ctx), klen, ivlen) ;
    EVP_CIPHER_CTX_set_key_length(&ctx, EPC_KEYLEN);
    klen = EVP_CIPHER_CTX_key_length(&ctx) ;
    ivlen = EVP_CIPHER_CTX_iv_length(&ctx) ;
            

    printf ("2 chiper=%s klen=%d ivlen=%d\n",
    EVP_CIPHER_CTX_cipher(&ctx), klen, ivlen) ;
    */
    
    
    EVP_CipherInit(&ctx, EPC_CHIPER, key, iv, do_encrypt);
    
    EVP_CIPHER_CTX_set_key_length(&ctx, EPC_KEYLEN);
        
    klen = EVP_CIPHER_CTX_key_length(&ctx) ;
    ivlen = EVP_CIPHER_CTX_iv_length(&ctx) ;
                
    if (klen > EPC_KEYLEN || ivlen > 8)
        return -6 ;
        
    if (header)
        {
        int hlen = strlen(header) ;

        if (!do_encrypt)
            {
            inlen = fread(inbuf, 1, hlen, in);
            if (hlen != inlen || memcmp (inbuf, header, hlen) != 0)
                return -1 ; /* wrong header */
            }
        else
            fwrite(header, 1, hlen, out);
        }
    
    if (begin)
        {
        blen = strlen(begin) ;

        if (do_encrypt)
            {
            EVP_CipherUpdate(&ctx, outbuf, &outlen, begin, blen) ;
            fwrite(outbuf, 1, outlen, out);
            }
        }
        
    
    for(;;)
        {
        inlen = fread(inbuf, 1, 1024, in);
        if(inlen <= 0) 
	    break;
        
	EVP_CipherUpdate(&ctx, outbuf, &outlen, inbuf, inlen) ;
        
	if (blen && !do_encrypt && blen <= outlen)
            {
            if (memcmp (outbuf, begin, blen) != 0)
                return -2 ; /* wrong begin */
	    
	    if (blen < outlen)
		{
		if (output)
		    {
		    if (outcnt + outlen - blen > outsize)
			return -4 ; /* buffer overflow */
		    memcpy(output, outbuf + blen, outlen - blen) ;
		    output += outlen - blen ;
		    }
		else
		    {
		    if (blen < outlen)
			fwrite(outbuf + blen, 1, outlen - blen, out);
		    }
		}
            outcnt += outlen - blen ;
            blen = 0 ;
            }
        else
            {
            if (output)
                {
                if (outcnt + outlen > outsize)
                    return -4 ; /* buffer overflow */
                memcpy(output, outbuf, outlen) ;
                output += outlen ;
                }
            else
                {
                fwrite(outbuf, 1, outlen, out);
                }
            outcnt += outlen ;
            }

        }
    if(!EVP_CipherFinal(&ctx, outbuf, &outlen))
        return -5; /* error */

    if (output)
        {
        if (outcnt + outlen > outsize)
            return -4 ; /* buffer overflow */
        memcpy(output, outbuf, outlen) ;
        output += outlen ;
        }
    else
        {
        fwrite(outbuf, 1, outlen, out);
        }
    outcnt += outlen ;

    EVP_CIPHER_CTX_cleanup(&ctx);
    return outcnt ;
    }
    

#endif
  
            

#ifndef XS_VERSION

int main (int argc, char *argv[])

    {
#if EPC_ENABLE
    FILE * ifd ;
    FILE * ofd ;
    char * syntax = "Embperl" ;
    int rc ;
#endif

    puts ("\nEmbperl encryption tool / Vers. 1.0 / (c) 2001 G.Richter ecos gmbh\n") ;
    

#if EPC_ENABLE == 0

    puts ("\nEncryption not enabled! see crypto/epcrypt_config.h\n") ;
    exit (1) ;

#else


    if (argc < 3)
        {
        puts ("Usage: epcrypto <inputfile> <outputfile> [<syntax>] [<decrypt>]") ;
        puts ("       syntax defaults to 'Embperl'") ;
        puts ("       decrypt defaults to false") ;
        exit (1) ;
        }

    if (argc > 3)
        syntax = argv[3] ;

    if (!(ifd = fopen (argv[1], "r")))
        {
        printf ("Cannot open '%s' for reading (%s)\n", argv[1], strerror( errno ) ) ;
        exit (1) ;
        }


    if (!(ofd = fopen (argv[2], "w")))
        {
        printf ("Cannot open '%s' for writing (%s)\n", argv[2], strerror( errno ) ) ;
        exit (1) ;
        }

    if ((rc = do_crypt_file (ifd, ofd, NULL, 0, argc > 4 && argv[4][0] != '\0' && argv[4][0] != '0'?0:1, syntax, EPC_HEADER)) <= 0)
        {
        if (rc == -1)
            {
            printf ("'%s' is not an Embperl encrypted file\n", argv[1]) ;
            }
        else if (rc == -2)
            {
            printf ("'%s' is wrong Syntax for '%s'\n", syntax, argv[1]) ;
            }
        printf ("Error while processing '%s' (%s)\n", argv[1], strerror( errno ) ) ;
        exit (1) ;
        }
    

    return 0 ;
#endif

    }


#endif