Quadcap Embeddable Database

com/quadcap/sql/file/EncryptedBlockStore.java

Go to the documentation of this file.

package com.quadcap.sql.file;

/*
 * Copyright 1999 by Stan Bailes and Quadcap Software.
 *
 **/

import java.io.IOException;

import java.nio.ByteBuffer;

import com.quadcap.crypto.Digest;
import com.quadcap.crypto.Key;
import com.quadcap.crypto.KeyFactory;
import com.quadcap.crypto.SymmetricKey;

/**
 * 
 *
 * @author Stan Bailes
 */
public class EncryptedBlockStore extends BlockStore {
    SymmetricKey                key;
    Key                         encrypt;
    Key                         decrypt;
    byte[]                      buf0;
    ByteBuffer                  b0;

    /**
     * Create a new EncryptedBlockStore object using the specified file and
     * blocksize.
     *
     * @param file the underlying file.
     * @param ra the randomly-accessible version of the file.
     * @param blocksize the block size to use for accessing the file.
     */
    public EncryptedBlockStore() {
    }

    static final int oHASH_PASSWD_start = BlockFile.oHASH_PASSWD_start;
    static final int oHASH_PASSWD_len = BlockFile.oHASH_PASSWD_len;

    public void setKey(SymmetricKey key) throws IOException {
        this.key = key;
        this.encrypt = key.getEncryptionKey();
        this.decrypt = key.getDecryptionKey();
        this.buf0 = new byte[blockSize];
        b0 = ByteBuffer.wrap(buf0);
        byte[] digest = makeDigest(key.toString());
        if (!isEncrypted()) {
            synchronized (lock) {
                buf0[0] = 0x0e;     // 4c -> ec! Encrypted.
                fra.write(0, buf0, 0, 1);
                fra.write(oHASH_PASSWD_start, digest, 0, digest.length);
            }
        } else {
            synchronized (lock) {
                fra.read(oHASH_PASSWD_start, buf0, 0, oHASH_PASSWD_len);
                for (int i = 0; i < digest.length; i++) {
                    if (digest[i] != buf0[i]) {
                        throw new IOException("Bad username/password");
                    }
                }
            }
        }
    }

    byte[] makeDigest(String s) {
        Digest d = KeyFactory.createDigest("SHA1");
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            d.update((byte)((c >> 8) & 0xff));
            d.update((byte)(c & 0xff));
        }
        return d.digest();
    }

    /**
     * Read a block into a buffer.  If the specified block is beyond the
     * current end of file, then grow the file
     *
     * @param blockNum the number of the block to read.
     * @param buf the buffer into which the data is read.
     */
    public void read(long blockNum, byte[] buf)
        throws IOException
    {
        synchronized (lock) {
            if (blockNum != 0 && decrypt != null) {
                super.read(blockNum, buf0);
                b0.rewind();
                decrypt.f(b0, ByteBuffer.wrap(buf));
            } else {
                super.read(blockNum, buf);
            }
        }
    }

    /**
     * Write a block from a buffer into the file.
     *
     * @param blockNum the number of the block to write.
     * @param buf the buffer from which the data is written.
     * @exception IOException if an I/O error occurs.
     */
    public void write(long blockNum, byte[] buf)
        throws IOException
    {
        synchronized (lock) {
            if (blockNum != 0 && encrypt != null) {
                b0.clear();
                encrypt.f(ByteBuffer.wrap(buf), b0);
                super.write(blockNum, buf0);
            } else {
                super.write(blockNum, buf);
            }
        }
    }        
}