/*
KeyringEditor

Copyright 2004 Markus Griessnig
Vienna University of Technology
Institute of Computer Technology

KeyringEditor is based on:
Java Keyring v0.6
Copyright 2004 Frank Taylor <keyring@lieder.me.uk>

These programs are distributed in the hope that they will be useful, but WITHOUT ANY WARRANTY;
without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU General Public License for more details.
*/

// Model.java

// 29.10.2004

// 31.10.2004: backup header and categories for saveData()
// 02.11.2004: class entry changed; added parameter -e; added parameter -d
// 03.11.2004: added getDateType()
// 04.11.2004: added getDataFormat()
// 06.11.2004: added debugByteArray()
// 08.11.2004: Categories-Array with 276 byte
// 11.11.2004: addes elements(), getCategoryName(), getCategories(); loadData - empty title possible
// 17.11.2004: setPassword uses char[] (security reason)
// 23.11.2004: added saveEntriesToFile()
// 24.11.2004: updated saveEntriesToFile(); updated saveData()
// 30.11.2004: printHexByteArray() added
// 01.12.2004: Keyring database format 5 support added
// 02.12.2004: toRecordFormat5() added
// 05.12.2004: convertDatabase() added
// 07.12.2004: convertDatabase() updated
// 12.01.2004: writeNewDatabase() added
// 07.09.2005: loadDatabase() ignores deleted record table entries
// 23.09.2005: added getNewUniqueId()

import java.io.*;
import java.util.*;

/**
 * This class is used to load and save Keyring databases.
 */
public class Model {
	// ----------------------------------------------------------------
	// variables
	// ----------------------------------------------------------------

	/**
	 * Field type & creator in PDB header information:
	 * Used by Palm OS to determine the application for the database.
	 * I am not sure if v2.0 will use the same creator-name as v1.2.2.
	 * At the moment v2.0-pre1 uses a different creator-name.
	 *
	 * v2.0-pre4 uses the same creator-name.
	 */
	private static String applcreator4 = "GkyrGtkr";
	private static String applcreator5 = "GkyrGtkr";

	public static final boolean DEBUG = false;

	// saveEntriesToFile()
	/**
	 * Filename of CSV File
	 */
	private static String csvFilename = "keyring.csv"; // default

	/**
	 * CSV-Separator
	 */
	private static char csvSeparator = ';'; // default

	// PDB header information (readPDBHeader)
	/**
	 * Header of Keyring database
	 */
	private byte[] pdbHeader = new byte[78];

	/**
	 * Categories in Keyring database
	 */
	private byte[] pdbCategories = new byte[276];

	private String pdbName;        // 32
	private int pdbFlags;          // 2 (unsigned)

	/**
	 * Keyring database version
	 */
	protected int pdbVersion;      // 2 (unsigned) // Keyring database format
	private long pdbModNumber;     // 4 (unsigned), modification number
	private int pdbSortInfoOffset; // 4
	private String pdbType;        // 4
	private String pdbCreator;     // 4
	private int pdbAppInfoOffset;  // 4

	/**
	 * Number of records in the keyring database
	 */
	private int pdbNumRecords;     // 2

	// Keyring database format 4
	private int recordZeroAttribute;
	private int recordZeroUniqueId;
	private int recordZeroLength;

	/**
	 * Vector to entry objects
	 */
	//private Vector<Entry> entries = new Vector<Entry>(); // Java 1.5
	private Vector entries = new Vector(); // reference to entry objects

	/**
	 * Vector to category strings
	 */
	//private Vector<String> categories = new Vector<String>(); // Java 1.5
	private Vector categories = new Vector(); // category labels

	/**
	 * Reference to class Crypto
	 */
	protected Crypto crypto; // Gui.java

	// ----------------------------------------------------------------
	// public ---------------------------------------------------------
	// ----------------------------------------------------------------

	// writeNewDatabase -----------------------------------------------
	/**
	 * This method dumps a minimal database with password "test".
	 *
	 * @param filename New database filename
	 */
	public static void writeNewDatabase(String filename) {
		int[] header = {
			0x4B, 0x65, 0x79, 0x73, 0x2D, 0x47, 0x74, 0x6B, 0x72, 0x00,
			0x6B, 0x72, 0x5F, 0x61, 0x70, 0x70, 0x6C, 0x5F, 0x61, 0x36,
			0x38, 0x6B, 0x00, 0x00, 0x73, 0x79, 0x73, 0x70, 0x04, 0x00,
			0x73, 0x70, 0x00, 0x08, 0x00, 0x04, 0xBD, 0xDB, 0x65, 0x06,
			0xBD, 0xDB, 0x65, 0x0D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
			0x00, 0x0E, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x00,
			0x47, 0x6B, 0x79, 0x72, 0x47, 0x74, 0x6B, 0x72, 0x00, 0xB7,
			0x30, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00,
			0x01, 0x74, 0x50, 0xB7, 0x30, 0x01, 0x00, 0x00, 0x01, 0x88,
			0x40, 0xB7, 0x30, 0x02, 0x00, 0x00, 0x1F, 0x1F};

		int[] data = {
			0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09,
			0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x0F, 0x00, 0xB0, 0xDA,
			0x43, 0x4A, 0x91, 0x55, 0x12, 0xEC, 0xD5, 0x96, 0xCD, 0x21,
			0x9A, 0xFC, 0x2D, 0x01, 0x9C, 0x2F, 0xC7, 0x13, 0x61, 0x00,
			0xF0, 0x3B, 0x16, 0xCC, 0x25, 0xCF, 0x49, 0xC0};

		int i;
		File db;
		FileOutputStream fp;
		byte[] cat = new byte[256];
		byte[] cat1 = (new String("no category")).getBytes();

		// open new database
		try {
			db = new File(filename);
			fp = new FileOutputStream(db);

			// write header
			for(i=0; i<header.length; i++) {
				fp.write((byte)header[i]);
			}

			// write category-names
			Arrays.fill(cat, (byte)0x00);
			System.arraycopy(cat1, 0, cat, 0, cat1.length);
			fp.write(cat, 0, 256);

			// write password information and record 1
			for(i=0; i<data.length; i++) {
				fp.write((byte)data[i]);
			}

			fp.close();
		}
		catch(Exception e) {
			System.err.println("Caught Exception: " + e.getMessage());
		}
	}

	// entries --------------------------------------------------------
	/**
	 * This method adds an entry to the vector entries.
	 *
	 * @param entry Entry object
	 */
	public void addEntry(Object entry) {
		entries.add((Entry)entry);
	}

	/**
	 * This method removes an entry from the vector entries.
	 *
	 * @param entry Entry object
	 */
	public void removeEntry(Object entry) {
		entries.removeElement(entry);
	}

	/**
	 * This method returns the size of vector entries.
	 *
	 * @return Size of vector entries
	 */
	public int getEntriesSize() {
		return entries.size();
	}

	/**
	 * This method returns the vector entries.
	 *
	 * @return Vector entries
	 */
	//public Vector<Entry> getEntries() { // Java 1.5
	public Vector getEntries() {
		return entries;
	}

	/**
	 * This method returns the enumeration of vector entries.
	 *
	 * @return Enumeration of vector entries
	 */
	public Enumeration getElements() {
		return entries.elements();
	}

	// categories -----------------------------------------------------
	/**
	 * This method returns a category name from the vector categories.
	 *
	 * @param category Index of category in vector categories
	 *
	 * @return Category name
	 */
	public String getCategoryName(int category) throws ArrayIndexOutOfBoundsException {
		return (String)categories.get(category);
	}

	/**
	 * This method sets the vector categories to the specified vector.
	 *
	 * @param myCategories New category vector
	 */
	//public void setCategories(Vector<String> myCategories) { // Java 1.5
	public void setCategories(Vector myCategories) {
		categories = myCategories;
	}

	/**
	 * This method returns the vector categories.
	 *
	 * @return Vector categories
	 */
	//public Vector<String> getCategories() { // Java 1.5
	public Vector getCategories() {
		return categories;
	}

	// loadData -------------------------------------------------------
	/**
	 * This method loads a Keyring database and generates entry objects for each account.
	 *
	 * @param filename Keyring database
	 */
	public void loadData(String filename) throws Exception {
		File db;
		FileInputStream fp;
		byte[] data;
		byte[] encrypted = null;
		int bufferSize = 100*1024;
		int entryLength;
		int pdbLength;
		int emptyTitle = 0;
		int start = 0;
		int len;
		int reallen;
		byte[] iv = null;
		String title = null;

		// record entry descriptors
		int pdbOffset[];    // 4
		int pdbAttribute[]; // 1
		int pdbUniqueId[];  // 3

		// initialisation
		entries.clear();
		categories.clear();

		// read database
		db = new File(filename);
		fp = new FileInputStream(db);

		data = new byte[bufferSize];

		pdbLength = fp.read(data);

		if(pdbLength == bufferSize) {
			throw new Exception("File too large.");
		}

		fp.close();

		if(DEBUG) {
			System.out.println("\n========== loadData() ==========\n");
		}

		// read header
		pdbHeader = sliceBytes(data, 0, 78);
		pdbName = sliceString(data, 0, 32);
		pdbFlags = (int)sliceNumber(data, 32, 2);
		pdbVersion = (int)sliceNumber(data, 34, 2); // 12 byte time information
		pdbModNumber = sliceNumber(data, 48, 4);
		pdbAppInfoOffset = (int)sliceNumber(data, 52, 4);
		pdbSortInfoOffset = (int)sliceNumber(data, 56, 4);
		pdbType = sliceString(data, 60, 4);
		pdbCreator = new String(data, 64, 4); // 8 byte unknown
		pdbNumRecords = (int)sliceNumber(data, 76, 2);

		// check Keyring database format
		if(!(pdbVersion == 4 || pdbVersion == 5)) {
			throw new Exception("Wrong Keyring database format.");
		}

		// offsets
		pdbOffset = new int[pdbNumRecords];
		pdbAttribute = new int[pdbNumRecords];
		pdbUniqueId = new int[pdbNumRecords];

		for(int i=0; i<pdbNumRecords; i++) {
			pdbOffset[i] = (int)sliceNumber(data, 78 + (i*8), 4);
			pdbAttribute[i] = (int)(sliceNumber(data, 78 + 4 + (i*8), 1));
			pdbUniqueId[i] = (int)sliceNumber(data, 78 + 4 + 1 + (i*8), 3);

			if(DEBUG) {
				System.out.println(i + ": " + pdbOffset[i]+ " / " + pdbAttribute[i] + " / " + pdbUniqueId[i]);
			}
		}

		if(DEBUG) {
			printPDBHeader();
		}

		pdbCategories = sliceBytes(data, pdbAppInfoOffset, 276);

		// determine the category list
		for(int i=0; i<16; i++) {
			String categoryName = sliceString(data, pdbAppInfoOffset + 2 + (16 * i), 16);

			if (!categoryName.equals("")) {
				categories.add(categoryName);
			}
		}

		if(pdbVersion == 5) {
			if(pdbNumRecords <= 0) {
				throw new Exception("No real data.");
			}

			byte[] salt = sliceBytes(data, pdbAppInfoOffset + 276, 8);
			int iter = (int)sliceNumber(data, pdbAppInfoOffset + 276 + 8, 2);
			int cipher = (int)sliceNumber(data, pdbAppInfoOffset + 276 + 8 + 2, 2);
			byte[] hash = sliceBytes(data, pdbAppInfoOffset + 276 + 8 + 2 + 2, 8);

			// initialize crypto Object
			crypto = new Crypto(null, 5, salt, hash, iter, cipher);

			start = 0; // start with first record

			switch(cipher) {
				case 1: break; // triple des
				case 2: break; // aes 128 bit
				case 3: break; // aes 256 bit
				default: throw new Exception("No cipher not supported.");
			}
		}

		if(pdbVersion == 4) {
			if(pdbNumRecords <= 1) { // only password information
				throw new Exception("No real data.");
			}

			recordZeroAttribute = pdbAttribute[0];
			recordZeroUniqueId = pdbUniqueId[0];
			recordZeroLength = pdbOffset[1] - pdbOffset[0];

			// load up password information (entry 0)
			crypto = new Crypto(sliceBytes(data, pdbOffset[0], pdbOffset[1] - pdbOffset[0]), 4);

			start = 1; // start with second record
		}

		// example (Keyring database format 4):
		// numberOfEntries = 4
		// entry 0 = password information
		// entry 1
		// entry 2
		// entry 3

		for(int i=start; i<pdbNumRecords; i++) {

			// check record attribute
			if((pdbAttribute[i] & 0xF0) == 0x40) {
                // determine entry length
                if(i == pdbNumRecords - 1) {
                    entryLength = pdbLength - pdbOffset[i];
                }
                else {
                    entryLength = pdbOffset[i+1] - pdbOffset[i];
                }

                //if(DEBUG) {
                //    System.out.println("i=" + i + ": " + pdbOffset[i] + " / " + entryLength);
                //}

                if(pdbVersion == 4) { // Keyring database format 4
                    // title + \0 + encrypted data
                    title = sliceString(data, pdbOffset[i], -1);
                    iv = null;
                    encrypted = sliceBytes(data, pdbOffset[i] + title.length() + 1, entryLength - title.length() - 1);
                }

                if(pdbVersion == 5) {
                    // get length of field
                    len = (int)sliceNumber(data, pdbOffset[i], 2);
                    reallen = (len + 1) & ~1; // padding for next even address

                    title = sliceString(data, pdbOffset[i] + 4, len);

                    int ivlen = 8; // tripledes
                    if(crypto.type == 2 || crypto.type == 3) ivlen = 16; // aes

                    iv = sliceBytes(data, pdbOffset[i] + reallen + 4, ivlen);
                    encrypted = sliceBytes(data, pdbOffset[i] + reallen + 4 + ivlen, entryLength - (reallen + 4 + ivlen));
                }

                // Keyring: empty title possible
                if(title.equals("")) {
                    title = "#" + (emptyTitle++);
                }

                // generate entry object
                Entry myEntry = new Entry(
                    i,
                    title,
                    pdbAttribute[i] & 15,
                    encrypted,
                    crypto,
                    pdbAttribute[i],
                    pdbUniqueId[i],
                    entryLength,
                    iv);

                //entries.add(myEntry); // Java 1.5
                entries.add((Object)myEntry);
            }
		}
	}

	// saveData -------------------------------------------------------
	/**
	 * This method calls the saveData method according to database version (pdbVersion).
	 *
	 * @param filename Keyring database
	 */
	public void saveData(String filename) throws Exception {
		if(DEBUG) {
			 System.out.println("saveData");
		}

		switch(pdbVersion) {
			case 4: saveData_4(filename); break;
			case 5: saveData_5(filename); break;
		}
	}

	/**
	 * This method saves all entries in the specified database (Database format 4).
	 *
	 * @param filename Keyring database
	 */
	public void saveData_4(String filename) throws Exception {
		File db;
		FileOutputStream fp;
		int offset = 0;

		// open new database
		db = new File(filename);
		fp = new FileOutputStream(db);

		pdbAppInfoOffset = 78 + 8 * entries.size() + 2 + 8; // + 8 for recordZero
		pdbNumRecords = entries.size() + 1;
		offset = pdbAppInfoOffset + 276;

		// write header
		fp.write(pdbHeader, 0, 52);
		fp.write(numberToByte(pdbAppInfoOffset, 4), 0, 4);
		fp.write(pdbHeader, 56, 20);
		fp.write(numberToByte(pdbNumRecords, 2), 0, 2); // + 1 for recordZero

		// write offset recordZero
		fp.write(numberToByte(offset, 4), 0, 4);
		fp.write(numberToByte(recordZeroAttribute, 1), 0, 1);
		fp.write(numberToByte(recordZeroUniqueId, 3), 0, 3);

		offset += recordZeroLength;

		// write offsets
		for(Enumeration e = entries.elements(); e.hasMoreElements(); ) {
			Entry entry = (Entry)e.nextElement();

			fp.write(numberToByte(offset, 4), 0, 4);
			fp.write(numberToByte(entry.attribute, 1), 0, 1); // category
			fp.write(numberToByte(entry.uniqueId, 3), 0, 3);

			if(DEBUG) {
				System.out.println("saveData4: " + offset + ", " + entry.attribute + ", " + entry.uniqueId);
			}

			offset += entry.recordLength;
		}

		fp.write((int)0x0000);
		fp.write((int)0x0000);

		// write categories
		updateCategories(); // Categories in Gui.java are editable
		fp.write(pdbCategories, 0, 276);

		// write password information
		fp.write(crypto.recordZero);

		// write records
		for(Enumeration e = entries.elements(); e.hasMoreElements(); ) {
			Entry entry = (Entry)e.nextElement();

			fp.write(entry.getTitle().getBytes());
			fp.write(0x00);
			fp.write(entry.encrypted);
		}

		fp.close();
	}

	/**
	 * This method saves all entries in the specified database (Database format 5).
	 *
	 * @param filename Keyring database
	 */
	public void saveData_5(String filename) throws Exception {
		File db;
		FileOutputStream fp;
		int offset = 0;

		// open new database
		db = new File(filename);
		fp = new FileOutputStream(db);

		pdbAppInfoOffset = 78 + 8 * entries.size() + 2;
		pdbNumRecords = entries.size();
		offset = pdbAppInfoOffset + 276 + 20; // salt hash type

		// write header
		fp.write(pdbHeader, 0, 52);
		fp.write(numberToByte(pdbAppInfoOffset, 4), 0, 4);
		fp.write(pdbHeader, 56, 20);
		fp.write(numberToByte(pdbNumRecords, 2), 0, 2); // + 1 for recordZero

		// write offsets
		for(Enumeration e = entries.elements(); e.hasMoreElements(); ) {
			Entry entry = (Entry)e.nextElement();

			fp.write(numberToByte(offset, 4), 0, 4);
			fp.write(numberToByte(entry.attribute, 1), 0, 1); // category
			fp.write(numberToByte(entry.uniqueId, 3), 0, 3);

			offset += entry.recordLength;
		}

		fp.write((int)0x0000);
		fp.write((int)0x0000);

		// write categories
		updateCategories(); // Categories in Gui.java are editable
		fp.write(pdbCategories, 0, 276);

		// write SALT HASH TYPE (db_format.txt)
		fp.write(crypto.salt);
		fp.write(numberToByte(crypto.iter, 2));
		fp.write(numberToByte(crypto.type, 2));
		fp.write(crypto.hash);

		// write records
		for(Enumeration e = entries.elements(); e.hasMoreElements(); ) {
			Entry entry = (Entry)e.nextElement();

			fp.write(convertStringToField(entry.getTitle(), 0));
			fp.write(entry.iv);
			fp.write(entry.encrypted);
		}

		fp.close();
	}

	// convertDatabase ------------------------------------------------
	/**
	 * This method calls convertTo method according to database format.
	 *
	 * @param from Database format of loaded database
	 * @param to Convert to database format
	 * @param filename New keyring database
	 * @param pw Password of new database
	 * @param type Cipher type (for database format 5)
	 * @param iter Iterations (for database format 5)
	 */
	public void convertDatabase(int from, int to, String filename, char[] pw, int type, int iter) throws Exception {
		switch(to) {
			case 4: convertTo_4(from, filename, pw); break;
			case 5: convertTo_5(from, filename, pw, type, iter); break;
			default: return;
		}
	}

	/**
	 * This method converts all entries to database format 4 and saves to specified database.
	 *
	 * @param from Database format of loaded database
	 * @param filename New keyring database
	 * @param pw Password of new database
	 */
	public void convertTo_4(int from, String filename, char[] pw) throws Exception {
	// Keyring database format 4
		File db;
		FileOutputStream fp;
		int i;
		int offset = 0;
		byte[] recordzero = new byte[20];
		byte[] pass = new byte[pw.length];
		byte[] salt = new byte[4];
		byte[] record = null;
		byte[] ciphertext = null;
		Crypto converted = null;

		// open new database
		db = new File(filename);
		fp = new FileOutputStream(db);

		pdbAppInfoOffset = 78 + 8 * entries.size() + 2 + 8; // + 8 for recordZero
		pdbNumRecords = entries.size() + 1;
		offset = pdbAppInfoOffset + 276;

		// create record zero
		Arrays.fill(recordzero, (byte)0);

		// Keyring supports passwords of up to 40 characters
		if(pw.length > 40) {
			throw new Exception("Password too long.");
		}

		// convert password from char to byte
		for(i=0;i<pw.length;i++) {
			pass[i] = (byte)(0xff & pw[i]);
		}

		// get salt
		switch(from) {
			case 4: // convert from 4 to 4 (changing password)
				for(i=0;i<4;i++) {
					salt[i] = crypto.recordZero[i]; // get old salt
					recordzero[i] = crypto.recordZero[i];
				}

				break;

			case 5:
				// take first 4 bytes from format 5 salt
				for(i=0;i<4;i++) {
					salt[i] = crypto.salt[i];
					recordzero[i] = crypto.salt[i];
				}

				break;
		}

		// get hash from password
		byte[] hash = crypto.checkPasswordHash_4(salt, pass);

		// fill recordzero
		for(i=0; i<16; i++) {
			recordzero[i+4] = hash[i];
		}

		// new crypto object
		converted = new Crypto(recordzero, 4);
		converted.setPassword(pw);

		Arrays.fill(pw, (char)0);
		Arrays.fill(pass, (byte)0);

		// write header
		fp.write(pdbHeader, 0, 34);
		fp.write(numberToByte(4, 2), 0, 2); // write new version
		fp.write(pdbHeader, 36, 16);
		fp.write(numberToByte(pdbAppInfoOffset, 4), 0, 4);
		//fp.write(pdbHeader, 56, 20);
		fp.write(pdbHeader, 56, 4); // sort info offset
		fp.write(applcreator4.getBytes()); // type, creator
		fp.write(pdbHeader, 68, 8); // sort info offset
		fp.write(numberToByte(pdbNumRecords, 2), 0, 2); // + 1 for recordZero

		// write offset recordZero
		fp.write(numberToByte(offset, 4), 0, 4);
		fp.write(numberToByte(80, 1), 0, 1);
		fp.write(numberToByte(0, 3), 0, 3);
		offset += 20;

		// write offsets
		for(Enumeration e = entries.elements(); e.hasMoreElements(); ) {
			Entry entry = (Entry)e.nextElement();

			fp.write(numberToByte(offset, 4), 0, 4);
			fp.write(numberToByte(entry.attribute, 1), 0, 1); // category
			fp.write(numberToByte(entry.uniqueId, 3), 0, 3);

			// decrypt and encrypt records
			record = Model.toRecordFormat4(
				entry.getAccount() + "\0" +
				entry.getPassword() + "\0" +
				entry.getNotes() + "\0");

			ciphertext = converted.encrypt(record);

			entry.encrypted = sliceBytes(ciphertext, 16, ciphertext.length - 16); // 16 byte iv ignored

			offset += entry.getTitle().length() + 1 + entry.encrypted.length;
		}

		fp.write((int)0x0000);
		fp.write((int)0x0000);

		// write categories
		updateCategories();
		fp.write(pdbCategories, 0, 276);

		// write password information
		fp.write(recordzero);

		// write records
		for(Enumeration e = entries.elements(); e.hasMoreElements(); ) {
			Entry entry = (Entry)e.nextElement();

			fp.write(entry.getTitle().getBytes());
			fp.write(0x00);
			fp.write(entry.encrypted);
		}

		converted = null;

		fp.close();
	}

	/**
	 * This method converts all entries to database format 5 and saves to specified database.
	 *
	 * @param from Database format of loaded database
	 * @param filename New keyring database
	 * @param pw Password of new database
	 * @param type Cipher type (for database format 5)
	 * @param iter Iterations (for database format 5)
	 */
	public void convertTo_5(int from, String filename, char[] pw, int type, int iter) throws Exception {
	// Keyring database format 5
		File db;
		FileOutputStream fp;
		int i;
		int offset = 0;
		byte[] record = null;
		byte[] ciphertext = null;
		byte[] salthashtype = new byte[20];
		Crypto converted = null;
		int[] cipherlen = {0, 24, 16, 32}; // keylength in byte
		byte[] pass = new byte[pw.length];
		byte[] salt = new byte[8];
		int index;

		for(i=0;i<pw.length;i++) {
			pass[i] = (byte)(0xFF & pw[i]);
		}

		// open new database
		db = new File(filename);
		fp = new FileOutputStream(db);

		pdbAppInfoOffset = 78 + 8 * entries.size() + 2;
		pdbNumRecords = entries.size();
		offset = pdbAppInfoOffset + 276 + 20; // salt hash type

		switch(from) {
			case 4:
				for(i=0; i<4; i++) {
					salt[i] = crypto.recordZero[i];
					salt[i+4] = crypto.recordZero[i];
				}
				break;

			case 5:
				for(i=0; i<8; i++) {
					salt[i] = crypto.salt[i];
				}
				break;
		}

		// PKCS#5 PBKDF2
		// Key Derivation function
		byte[] deskey = crypto.pbkdf2(pass, salt, iter, cipherlen[type]);

		// set odd parity
		if(type == 1) { // TripleDES
			for(i=0; i<24; i++) {
				index = (int)(0xff & deskey[i]);
				deskey[i] = (byte)crypto.odd_parity[index];
			}
		}

		// SHA1
		byte[] digest = crypto.getMessageDigest(deskey, salt);

		byte[] hash = Model.sliceBytes(digest, 0, 8);

		converted = new Crypto(null, 5, salt, hash, iter, type);
		converted.setPassword(pw);

		Arrays.fill(pw, (char)0);
		Arrays.fill(pass, (byte)0);

		// write header
		fp.write(pdbHeader, 0, 34);
		fp.write(numberToByte(5, 2), 0, 2); // write new version
		fp.write(pdbHeader, 36, 16);
		fp.write(numberToByte(pdbAppInfoOffset, 4), 0, 4); // application info offset
		//fp.write(pdbHeader, 56, 20);
		fp.write(pdbHeader, 56, 4); // sort info offset
		fp.write(applcreator5.getBytes()); // type, creator
		fp.write(pdbHeader, 68, 8); // sort info offset

		fp.write(numberToByte(pdbNumRecords, 2), 0, 2); // + 1 for recordZero

		// write offsets
		for(Enumeration e = entries.elements(); e.hasMoreElements(); ) {
			Entry entry = (Entry)e.nextElement();

			fp.write(numberToByte(offset, 4), 0, 4);
			fp.write(numberToByte(entry.attribute, 1), 0, 1); // category
			fp.write(numberToByte(entry.uniqueId, 3), 0, 3);

			// decrypt and encrypt records
			record = Model.toRecordFormat5(entry.getAccount(), entry.getPassword(), entry.getNotes());

			ciphertext = converted.encrypt(record);

			// extract iv
			int ivlen = 8;
			if(type != 1) { // TripleDES
				ivlen = 16; // AES128, AES256
			}

			entry.iv = sliceBytes(ciphertext, 0, ivlen);
			entry.encrypted = Model.sliceBytes(ciphertext, 16, ciphertext.length - 16);

			offset += (Model.convertStringToField(entry.getTitle(), 0)).length + ivlen + entry.encrypted.length;
		}

		fp.write((int)0x0000);
		fp.write((int)0x0000);

		// write categories
		updateCategories();
		fp.write(pdbCategories, 0, 276);

		// write SALT HASH TYPE (db_format.txt)
		fp.write(salt);
		fp.write(numberToByte(iter, 2));
		fp.write(numberToByte(type, 2));
		fp.write(hash);

		// write records
		for(Enumeration e = entries.elements(); e.hasMoreElements(); ) {
			Entry entry = (Entry)e.nextElement();

			fp.write(convertStringToField(entry.getTitle(), 0));
			fp.write(entry.iv);
			fp.write(entry.encrypted);
		}

		converted = null;

		fp.close();
	}

	// toRecordFormat4 ------------------------------------------------
	/**
	 * This method adds todays date (DateType format) to decrypted data (for database format 4).
	 *
	 * @param data Example: Account + \0 + Password + \0 + Notes + \0
	 *
	 * @return data + todays date in datetype format
	 */
	public static byte[] toRecordFormat4(String data) {
		byte[] today = getDateType();
		byte[] buffer = data.getBytes();
		byte[] result = new byte[buffer.length + 2];

		System.arraycopy(buffer, 0, result, 0, buffer.length);
		result[buffer.length] = today[1];
		result[buffer.length + 1] = today[0];

		return result;
	}

	// toRecordFormat5 ------------------------------------------------
	/**
	 * This method adds todays date (DateType format) to decrypted data (for database format 5).
	 *
	 * @param account Entry account
	 * @param password Entry password
	 * @param notes Entry notes
	 *
	 * @return decrypted data in database format 5
	 */
	public static byte[] toRecordFormat5(String account, String password, String notes) {
		// Format:
		// field (account)
		// field (password)
		// field (notes)
		// field (datetype)
		// 0xff
		// 0xff
		// random padding to multiple of 8 bytes
		byte[] datetype = {0x00, 0x02, 0x03, 0x00, 0x00, 0x00};

		byte[] field1 = account.getBytes();
		byte[] field2 = password.getBytes();
		byte[] field3 = notes.getBytes();

		int lenField1 = field1.length;
		int lenField2 = field2.length;
		int lenField3 = field3.length;

		if(lenField1 != 0) {
			field1 = convertStringToField(account, 1);
			lenField1 = field1.length;
		}

		if(lenField2 != 0) {
			field2 = convertStringToField(password, 2);
			lenField2 = field2.length;
		}

		if(lenField3 != 0) {
			field3 = convertStringToField(notes, 255);
			lenField3 = field3.length;
		}

		byte[] now = getDateType();
		datetype[4] = now[1];
		datetype[5] = now[0];

		int padding = (lenField1 + lenField2 + lenField3 + 6 + 2) % 8;
		byte[] result = new byte[lenField1 + lenField2 + lenField3 + 6 + 2 + padding];
		Arrays.fill(result, (byte)0xff);

		if(lenField1 != 0) {
			System.arraycopy(field1, 0, result, 0, lenField1);
		}

		if(lenField2 != 0) {
			System.arraycopy(field2, 0, result, lenField1, lenField2);
		}

		if(lenField3 != 0) {
			System.arraycopy(field3, 0, result, lenField1 + lenField2, lenField3);
		}

		System.arraycopy(datetype, 0, result, lenField1 + lenField2 + lenField3, 6);

		return result;
	}

	/**
	 * This method converts a string in the format used by database format 5 (Field).
	 *
	 * @param field Text
	 * @param label Label information (account=1, password=2, notes=255)
	 *
	 * @return Field
	 */
	public static byte[] convertStringToField(String field, int label) {
		// Format:
		// 2 byte length of field
		// 1 byte label
		// 1 byte 0x00
		// data
		// 0/1 padding for next even address
		byte[] buffer = field.getBytes();
		int padding = 0;
		int len = buffer.length;

		if((len % 2) == 1) {
			padding = 1;
		}

		byte[] result = new byte[4 + len + padding];
		Arrays.fill(result, (byte)0);

		System.arraycopy(numberToByte(len,2), 0, result, 0, 2);
		System.arraycopy(numberToByte(label,1), 0, result, 2, 1);
		result[3] = (byte)0x00;
		System.arraycopy(buffer, 0, result, 4, len);

		return result;
	}


	// getNewUniqueId -------------------------------------------------
	/**
	 * This method searches the entries for the highest id.
	 *
	 * @return New unique id
	 */
	public int getNewUniqueId() {
		int id = 0;

		for(Enumeration e = entries.elements(); e.hasMoreElements(); ) {

			Entry entry = (Entry)e.nextElement();

			if(entry.getUniqueId() > id) {
				id = entry.getUniqueId();
			}
		}

		id = id + 1;

		return(id);
	}

	// saveEntriesToFile ----------------------------------------------
	/**
	 * This method saves all entries to a csv file.
	 *
	 * @param filename CSV file
	 */
	public void saveEntriesToFile(String filename) throws Exception{
		csvFilename = filename;

		File outputFile = new File(csvFilename);
        FileWriter out = new FileWriter(outputFile);

		for(Enumeration e = entries.elements(); e.hasMoreElements(); ) {
			Entry entry = (Entry)e.nextElement();

			String buffer =
				"" + '"' + entry.getEntryId() + '"' + csvSeparator +
				'"' + categories.elementAt(entry.getCategory()) + '"' + csvSeparator +
				'"' + entry.getTitle() + '"' + csvSeparator +
				'"' + entry.getAccount() + '"' + csvSeparator +
				'"' + entry.getPassword() + '"' + csvSeparator +
				'"' + entry.getDate() + '"' + "\n";

			out.write(buffer.toCharArray());
		}

		out.close();
	}

	public void setCsvSeparator(char sep) {
		this.csvSeparator = sep;
	}

	public void setCsvFilename(String filename) {
		this.csvFilename = filename;
	}

	public String getCsvFilename() {
		return csvFilename;
	}

	// tools ----------------------------------------------------------
	/**
	 * This method converts a long into a byte array.
	 *
	 * @param number Number
	 * @param len Size of byte array
	 *
	 * @return Byte array representation of number
	 */
	public static byte[] numberToByte(long number, int len) {
		int i, shift;
		byte[] buffer = new byte[len];

		for(i=0, shift=((len-1) * 8); i<len; i++, shift -= 8) {
			buffer[i] = (byte)(0xFF & (number >> shift));
		}

		return buffer;
	}

	/**
	 * This method converts a byte to int.
	 *
	 * @param b Byte
	 *
	 * @return Int representation of Byte
	 */
	public static int unsignedByteToInt(byte b) {
		return (int)(b & 0xFF);
	}

	/**
	 * This method slices a byte array from an byte array.
	 *
	 * @param data Byte array
	 * @param start Index to start from
	 * @param length Length of byte array to slice out
	 *
	 * @return Byte array
	 */
	public static byte[] sliceBytes(byte[] data, int start, int length) {
		byte[] bytes = new byte[length];

		for(int i=0; i<length; i++) {
			bytes[i] = data[start + i];
		}

		return bytes;
	}

	/**
	 * This method slices a byte array from an byte array and converts it to a long.
	 *
	 * @param data Byte array
	 * @param start Index to start from
	 * @param length Length of byte array to slice out
	 *
	 * @return Long representation of the byte array
	 */
	public static long sliceNumber(byte[] data, int start, int length) {
		long value = 0, factor = 1;

		for(int i=0; i<length; i++) {
			value += (long)(unsignedByteToInt(data[start + length - (i + 1)]) * factor);
			factor *= 256;
		}

		return value;
	}

	/**
	 * This method slices a byte array from an byte array and converts it to a string.
	 *
	 * @param data Byte array
	 * @param start Index to start from
	 * @param length Length of byte array to slice out
	 *
	 * @return String representation of the byte array
	 */
	public static String sliceString(byte[] data, int start, int length) {
		int realLength = 0;

		if(length == -1) {
			// no specific max length (make it to the end of the array)
			length = data.length - start;
		}

		while(realLength < length && data[start + realLength] != 0) {
			realLength++;
		}

		return new String((byte[])data, start, realLength);
	}

	/**
	 * not used
	 */
	public static void printByteArray(String info, byte[] buffer) {
		System.out.print("printByteArray " + info + " (" + buffer.length + "): ");
		for(int i=0;i<buffer.length;i++) {
			System.out.print((int)(buffer[i] & 0xFF) + " ");
		}
		System.out.println();
	}

	/**
	 * not used
	 */
	public static void printHexByteArray(String info, byte[] buffer) {
		char[] hexNumbers = {'0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f'};
		int zahl, rest;

		System.out.println("printHexByteArray " + info + " (" + buffer.length + "): ");

		for(int i=0;i<buffer.length;i++) {

			zahl = (int)(buffer[i] & 0xFF) / 16;
			rest = (int)(buffer[i] & 0xFF) % 16;

			System.out.print("" + hexNumbers[zahl] + "" + hexNumbers[rest] + " ");
		}

		System.out.println();
	}

	// ----------------------------------------------------------------
	// private --------------------------------------------------------
	// ----------------------------------------------------------------

	/*
	private static void printUsage() {
		System.err.println("Usage:");
		System.err.println("View entries: java Model database.pdb password");
		System.err.println("   Add entry: ... -n title account password");
		System.err.println("  Edit entry: ... -e id title account passwort");
		System.err.println("Delete entry: ... -d id");
	}
	*/

	/**
	 * not used
	 */
	private void printPDBHeader() {
		System.out.println("PDB Name: " + pdbName);
		System.out.println("PDB Flags: " + pdbFlags);
		System.out.println("PDB Version: " + pdbVersion);
		System.out.println("PDB Modification Number: " + pdbModNumber);
		System.out.println("PDB AppInfoOffset: " + pdbAppInfoOffset);
		System.out.println("PDB SortInfoOffset: " + pdbSortInfoOffset);
		System.out.println("PDB Type: " + pdbType);
		System.out.println("PDB Creator: " + pdbCreator);
		System.out.println("PDB NumberOfRecords: " + pdbNumRecords + "\n");
	}

	/**
	 * not used
	 */
	private void printEntries() {
		int i=0;

		for(Enumeration c = categories.elements(); c.hasMoreElements(); ) {
			String help = (String)c.nextElement();

			System.out.println("Category " + (i++) + ": " + help);
		}
		System.out.println();

		for(Enumeration e = entries.elements(); e.hasMoreElements(); ) {
			Entry entry = (Entry)e.nextElement();

			System.out.println(entry.getInfo());
		}
		System.out.println();
	}

	// DateType -------------------------------------------------------
	/**
	 * This method return todays date in DateType format.
	 *
	 * @return Todays date in DateType format (byte[2])
	 */
	private static byte[] getDateType() {
		int day, month, year;
		int[] intResult = new int[2];
		byte[] byteResult = new byte[2];

		Calendar rightNow = new GregorianCalendar();

		day = rightNow.get(Calendar.DAY_OF_MONTH);
		month = rightNow.get(Calendar.MONTH) + 1; // Calender month from 0 to 11
		year = rightNow.get(Calendar.YEAR) - 1904; // DateType year since 1904

		day = (day & 0x1F); // 5 bit
		month = (month & 0x0F); // 4 bit
		year = (year & 0x7F); // 7 bit

		// DateType (2 bytes): 7 bit year, 4 bit month, 5 bit day
		intResult[0] = day | ((month & 0x07) << 5);
		intResult[1] = (year << 1) | ((month & 0x08) >> 3);

		// System.out.println(intResult[1] + " " + intResult[0]);
		byteResult[0] = (byte)intResult[0];
		byteResult[1] = (byte)intResult[1];

		return byteResult;
	}

	// updateCategories - saveData()
	/**
	 * This method updates the categories in variable pdbCategories according to vector categories.
	 */
	private void updateCategories() {
		byte[] cat = new byte[16];
		int index = 0;

		for(Enumeration c = categories.elements(); c.hasMoreElements(); ) {
			String strCategory = (String)c.nextElement();
			byte[] temp = strCategory.getBytes();

			// resize to 16 byte
			for(int i=0; i<16; i++) {
				if(i < temp.length)
					cat[i] = temp[i];
				else
					cat[i] = 0x00;
			}

			// overwrite old categories
			System.arraycopy(cat, 0, pdbCategories, 2 + (index * 16), 16);
			index++;
		}
	}
}