/**
 * This file is part of the dcrypt project.
 *
 * Copyright: Copyright (C) dcrypt contributors 2008. All rights reserved.
 * License:   MIT
 * Authors:   Thomas Dixon
 */

module dcrypt.crypto.Crypto;

// Hash functions
public import dcrypt.crypto.Hash;
import dcrypt.crypto.hashes.MD5;
import dcrypt.crypto.hashes.SHA1;
import dcrypt.crypto.hashes.SHA224;
import dcrypt.crypto.hashes.SHA256;
import dcrypt.crypto.hashes.SHA384;
import dcrypt.crypto.hashes.SHA512;

// Message authentication codes
public import dcrypt.crypto.MAC;
public import dcrypt.crypto.macs.HMAC;

// Params
public import dcrypt.crypto.params.SymmetricKey;
public import dcrypt.crypto.params.ParametersWithIV;

// Ciphers
public import dcrypt.crypto.Cipher;
public import dcrypt.crypto.BlockCipher;
public import dcrypt.crypto.StreamCipher;
public import dcrypt.crypto.BlockCipherWrapper;
import dcrypt.crypto.ciphers.Blowfish;
import dcrypt.crypto.ciphers.RC6;
import dcrypt.crypto.ciphers.TEA;
import dcrypt.crypto.ciphers.XTEA;
import dcrypt.crypto.ciphers.AES;
import dcrypt.crypto.ciphers.RC4;

// Block modes
import dcrypt.crypto.modes.CBC;
import dcrypt.crypto.modes.CTR;

// Block padding
public import dcrypt.crypto.BlockCipherPadding;
import dcrypt.crypto.padding.NullByte;
import dcrypt.crypto.padding.X923;
import dcrypt.crypto.padding.PKCS7;
import dcrypt.crypto.padding.RFC1321;

enum Hashes {
    MD5=0,
    SHA1,
    SHA224,
    SHA256,
    SHA384,
    SHA512
}

enum Ciphers {
    // Block ciphers
    Blowfish=0,
    AES,
    RC6,
    TEA,
    XTEA,
    
    // Stream ciphers
    RC4
}

enum Modes {
    ECB=-1,
    CTR,
    CBC
}

enum Padding {
    None=-1,
    NullByte, // lol
    X923,
    PKCS7,
    RFC1321
}

struct Crypto {
    static Hash createHash(uint hash) {
        switch (hash) {
            case Hashes.MD5:
                return new MD5;
            case Hashes.SHA1:
                return new SHA1;
            case Hashes.SHA224:
                return new SHA224;
            case Hashes.SHA256:
                return new SHA256;
            case Hashes.SHA384:
                return new SHA384;
            case Hashes.SHA512:
                return new SHA512;
            default:
                throw new InvalidParameterError("Unknown hash function passed to createHash()");
        }
    }
    
    static Cipher createCipher(uint cipher, int mode=Modes.ECB, int padding=Padding.None) {
        BlockCipher c = null,
                    m = null;
        BlockCipherPadding p = null;
        switch (cipher) {
            case Ciphers.Blowfish:
                c = new Blowfish;
                break;
            case Ciphers.AES:
                c = new AES;
                break;
            case Ciphers.RC6:
                c = new RC6;
                break;
            case Ciphers.TEA:
                c = new TEA;
                break;
            case Ciphers.XTEA:
                c = new XTEA;
                break;
            case Ciphers.RC4:
                return new RC4; // Note the return
            default:
                throw new InvalidParameterError("Unknown cipher passed to createCipher()");
        }
        
        switch (mode) {
            case Modes.ECB:
                break;
            case Modes.CTR:
                m = new CTR(c);
                break;
            case Modes.CBC:
                m = new CBC(c);
                break;
            default:
                throw new InvalidParameterError("Unknown mode passed to createCipher()");
        }
        
        switch (padding) {
            case Padding.None:
                break;
            case Padding.NullByte:
                p = new NullByte;
                break;
            case Padding.X923:
                p = new X923;
                break;
            case Padding.PKCS7:
                p = new PKCS7;
                break;
            case Padding.RFC1321:
                p = new RFC1321;
                break;
            default:
                throw new InvalidParameterError("Unknown padding passed to createCipher()");
        }
        
        return new BlockCipherWrapper(((m is null) ? c : m), p);
    }
}