Quadcap Embeddable Database

com/quadcap/crypto/KeyFactory.java

Go to the documentation of this file.

package com.quadcap.crypto;

/* Copyright 2002 - 2003 Quadcap Software.  All rights reserved.
 *
 * This software is distributed under the Quadcap Free Software License.
 * This software may be used or modified for any purpose, personal or
 * commercial.  Open Source redistributions are permitted.  Commercial
 * redistribution of larger works derived from, or works which bundle
 * this software requires a "Commercial Redistribution License"; see
 * http://www.quadcap.com/purchase.
 *
 * Redistributions qualify as "Open Source" under  one of the following terms:
 *   
 *    Redistributions are made at no charge beyond the reasonable cost of
 *    materials and delivery.
 *
 *    Redistributions are accompanied by a copy of the Source Code or by an
 *    irrevocable offer to provide a copy of the Source Code for up to three
 *    years at the cost of materials and delivery.  Such redistributions
 *    must allow further use, modification, and redistribution of the Source
 *    Code under substantially the same terms as this license.
 *
 * Redistributions of source code must retain the copyright notices as they
 * appear in each source code file, these license terms, and the
 * disclaimer/limitation of liability set forth as paragraph 6 below.
 *
 * Redistributions in binary form must reproduce this Copyright Notice,
 * these license terms, and the disclaimer/limitation of liability set
 * forth as paragraph 6 below, in the documentation and/or other materials
 * provided with the distribution.
 *
 * The Software is provided on an "AS IS" basis.  No warranty is
 * provided that the Software is free of defects, or fit for a
 * particular purpose.  
 *
 * Limitation of Liability. Quadcap Software shall not be liable
 * for any damages suffered by the Licensee or any third party resulting
 * from use of the Software.
 */

import java.util.Random;

/**
 * A simple key factory to localize the (hardcoded) choice of ciphers.
 *
 * @author Stan Bailes
 */
public class KeyFactory {
    /**
     * Create a symmetric key using the specified random number generator
     * and the default symmetric key algorithm
     */
    public static SymmetricKey createSymmetricKey(Random r) {
        SymmetricKey k = new Tea();
        k.init(r);
        return k;
    }

    /**
     * Create a symmetric key seeded with the specified pass phrase
     * This fellow creates a Rijndael 128 bit key
     */
    public static SymmetricKey createSymmetricKey(String passphrase) {
        return createSymmetricKey("aes:128", passphrase);
    }

    /**
     * Make the passphrase into a fixed size byte array with smearing
     */
    public static byte[] bytesFromPassphrase(int len, String passphrase) {
        byte[] key = new byte[len];
        long seed = 13 * passphrase.length();
        for (int i = 0; i < key.length; i++) {    
            int c = passphrase.charAt(i % passphrase.length());
            seed += (c << 18) ^ c;
            seed = (seed * 0x5DEECE66DL + 0xBL) & ((1L << 48) - 1);
            key[i] = (byte)((seed >> 5) & 0xff);
        }
        return key;
    }

    /**
     * Create a symmetric key from an algorithm specification and a pass
     * phrase.
     *
     */
    public static SymmetricKey createSymmetricKey(String algo,
                                                  String passphrase) {
        SymmetricKey k = null;
        
        algo = algo.toLowerCase();
        if (algo.startsWith("aes")) {
            int len = 16;
            int idx = algo.indexOf(':');
            if (idx > 0) {
                len = Integer.parseInt(algo.substring(idx+1)) / 8;
            }
            Rijndael rk = new Rijndael();
            rk.init(bytesFromPassphrase(len, passphrase));
            k = rk;
        } else if (algo.startsWith("tea:256")) {
            Tea256 tk = new Tea256();
            tk.init(bytesFromPassphrase(256, passphrase));
            k = tk;
        } else if (algo.startsWith("tea:128")) {
            Tea tk = new Tea();
            tk.init(bytesFromPassphrase(128, passphrase));
            k = tk;
        }
        return k;                
    }

    /**
     * Create a public/private key pair and return the private portion
     */
    public static PrivateKey createPrivateKey(Random r, String alg,
                                              String name) {
        RSAPrivateKey k = new RSAPrivateKey();
        k.init(name, 1024, r);
        return k;
    }

    /**
     * Restore a symmetric key from its serialized form
     */
    public static SymmetricKey readSymmetricKey(String s) {
        Tea t = new Tea();
        t.init(s);
        return t;
    }

    /**
     * Restore a public key from its serialized form
     */
    public static PublicKey readPublicKey(String s) {
        RSAPublicKey k = new RSAPublicKey();
        k.init(s);
        return k;
    }

    /**
     * Restore a private key from its serialized form
     */
    public static PrivateKey readPrivateKey(String s) {
        RSAPrivateKey k = new RSAPrivateKey();
        k.init(s);
        return k;
    }

    /**
     * Create a digest
     */
    public static Digest createDigest(String alg) {
        return new SHA1Digest();
    }

    public static Random createRandom(String seed) {
        Random r = new java.util.Random();
        r.setSeed(System.currentTimeMillis() * 1003 + seed.hashCode());
        return r;
    }

}