/**********************************************************************
 *
 * This file is part of HBCI4Java.
 * Copyright (c) 2001-2010 Stefan Palme
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 *
 **********************************************************************/

package org.kapott.cryptalgs;

import java.security.InvalidKeyException;
import java.security.MessageDigestSpi;
import java.security.NoSuchAlgorithmException;
import java.security.spec.InvalidKeySpecException;
import java.util.Arrays;

import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESKeySpec;

public final class MDC2
    extends MessageDigestSpi
{
    private byte[]           x;
    private byte             writePos;
    private byte[]           h1,h2;
    private SecretKeyFactory fac;
    private Cipher           cipher;
    
    private int[] odd_parity={
        1,  1,  2,  2,  4,  4,  7,  7,  8,  8, 11, 11, 13, 13, 14, 14,
        16, 16, 19, 19, 21, 21, 22, 22, 25, 25, 26, 26, 28, 28, 31, 31,
        32, 32, 35, 35, 37, 37, 38, 38, 41, 41, 42, 42, 44, 44, 47, 47,
        49, 49, 50, 50, 52, 52, 55, 55, 56, 56, 59, 59, 61, 61, 62, 62,
        64, 64, 67, 67, 69, 69, 70, 70, 73, 73, 74, 74, 76, 76, 79, 79,
        81, 81, 82, 82, 84, 84, 87, 87, 88, 88, 91, 91, 93, 93, 94, 94,
        97, 97, 98, 98,100,100,103,103,104,104,107,107,109,109,110,110,
        112,112,115,115,117,117,118,118,121,121,122,122,124,124,127,127,
        128,128,131,131,133,133,134,134,137,137,138,138,140,140,143,143,
        145,145,146,146,148,148,151,151,152,152,155,155,157,157,158,158,
        161,161,162,162,164,164,167,167,168,168,171,171,173,173,174,174,
        176,176,179,179,181,181,182,182,185,185,186,186,188,188,191,191,
        193,193,194,194,196,196,199,199,200,200,203,203,205,205,206,206,
        208,208,211,211,213,213,214,214,217,217,218,218,220,220,223,223,
        224,224,227,227,229,229,230,230,233,233,234,234,236,236,239,239,
        241,241,242,242,244,244,247,247,248,248,251,251,253,253,254,254};

    
    public MDC2()
    {
        this.x=new byte[8];
        this.h1=new byte[8];
        this.h2=new byte[8];
        
        try {
            this.fac=SecretKeyFactory.getInstance("DES");
            this.cipher=Cipher.getInstance("DES");
        } catch (NoSuchAlgorithmException e) {
            throw new RuntimeException(e);
        } catch (NoSuchPaddingException e) {
            throw new RuntimeException(e);
        }
        
        engineReset();
    }

    @Override
    protected byte[] engineDigest()
    {
        if (this.writePos!=0) {
            this.writePos=8;
            hashIt();
        }
        
        byte[] ret=new byte[16];
        System.arraycopy(this.h1,0,ret,0,8);
        System.arraycopy(this.h2,0,ret,8,8);
        
        engineReset();
        return ret;
    }

    @Override
    protected int engineDigest(byte[] buf, int offset, int len)
    {
        byte[] result=engineDigest();
        System.arraycopy(result,0,buf,offset,engineGetDigestLength());
        return engineGetDigestLength();
    }

    @Override
    protected int engineGetDigestLength()
    {
        return 16;
    }

    @Override
    protected void engineReset()
    {
        Arrays.fill(this.x,(byte)0);
        Arrays.fill(this.h1,(byte)0x52);
        Arrays.fill(this.h2,(byte)0x25);
        this.writePos=0;
    }

    @Override
    protected void engineUpdate(byte[] input, int offset, int len)
    {
        for (int i=0;i<len;i++)
            engineUpdate(input[offset+i]);
    }

    @Override
    protected void engineUpdate(byte input)
    {
        this.x[this.writePos++]=input;
        if ((this.writePos&0x07)==0) {
            // 8 byte boundary reached
            hashIt();
        }
    }

    private void hashIt()
    {
        byte[] k1=g(this.h1,(byte)0x40);
        byte[] k2=g(this.h2,(byte)0x20);

        byte[] c1=xor(des(this.x,k1),this.x);
        byte[] c2=xor(des(this.x,k2),this.x);

        System.arraycopy(c1,0,this.h1,0,4);
        System.arraycopy(c2,4,this.h1,4,4);
        System.arraycopy(c2,0,this.h2,0,4);
        System.arraycopy(c1,4,this.h2,4,4);

        Arrays.fill(this.x,(byte)0);
        this.writePos=0;
    }
    
    private byte[] g(byte[] u,byte modifier)
    {
        byte[] ret=new byte[8];
        System.arraycopy(u,0,ret,0,8);
        
        ret[0]=(byte)((ret[0]&(byte)0x9F) | modifier);
        
        for (int i=0;i<8;i++) {
            int idx=ret[i];
            if (idx<0)
                idx+=256;
            ret[i]=(byte)this.odd_parity[idx];
        }
        return ret;
    }

    private byte[] des(byte[] data,byte[] keydata)
    {
        byte[] ret=null;
        
        try {
            DESKeySpec spec=new DESKeySpec(keydata);
            SecretKey key=this.fac.generateSecret(spec);
            this.cipher.init(Cipher.ENCRYPT_MODE,key);
            ret=this.cipher.doFinal(data);
        } catch (InvalidKeyException e) {
            throw new RuntimeException(e);
        } catch (InvalidKeySpecException e) {
            throw new RuntimeException(e);
        } catch (IllegalBlockSizeException e) {
            throw new RuntimeException(e);
        } catch (BadPaddingException e) {
            throw new RuntimeException(e);
        }
        
        return ret;
    }
    
    private byte[] xor(byte[] x1,byte[] x2)
    {
        byte[] ret=new byte[8];
        
        for (int i=0;i<8;i++) {
            ret[i]=(byte)(x1[i]^x2[i]);
        }
        
        return ret;
    }
}
