001: package com.quadcap.crypto;
002:
003: /* Copyright 2002 - 2003 Quadcap Software. All rights reserved.
004: *
005: * This software is distributed under the Quadcap Free Software License.
006: * This software may be used or modified for any purpose, personal or
007: * commercial. Open Source redistributions are permitted. Commercial
008: * redistribution of larger works derived from, or works which bundle
009: * this software requires a "Commercial Redistribution License"; see
010: * http://www.quadcap.com/purchase.
011: *
012: * Redistributions qualify as "Open Source" under one of the following terms:
013: *
014: * Redistributions are made at no charge beyond the reasonable cost of
015: * materials and delivery.
016: *
017: * Redistributions are accompanied by a copy of the Source Code or by an
018: * irrevocable offer to provide a copy of the Source Code for up to three
019: * years at the cost of materials and delivery. Such redistributions
020: * must allow further use, modification, and redistribution of the Source
021: * Code under substantially the same terms as this license.
022: *
023: * Redistributions of source code must retain the copyright notices as they
024: * appear in each source code file, these license terms, and the
025: * disclaimer/limitation of liability set forth as paragraph 6 below.
026: *
027: * Redistributions in binary form must reproduce this Copyright Notice,
028: * these license terms, and the disclaimer/limitation of liability set
029: * forth as paragraph 6 below, in the documentation and/or other materials
030: * provided with the distribution.
031: *
032: * The Software is provided on an "AS IS" basis. No warranty is
033: * provided that the Software is free of defects, or fit for a
034: * particular purpose.
035: *
036: * Limitation of Liability. Quadcap Software shall not be liable
037: * for any damages suffered by the Licensee or any third party resulting
038: * from use of the Software.
039: */
040:
041: import java.util.Random;
042:
043: /**
044: * A simple key factory to localize the (hardcoded) choice of ciphers.
045: *
046: * @author Stan Bailes
047: */
048: public class KeyFactory {
049: /**
050: * Create a symmetric key using the specified random number generator
051: * and the default symmetric key algorithm
052: */
053: public static SymmetricKey createSymmetricKey(Random r) {
054: SymmetricKey k = new Tea();
055: k.init(r);
056: return k;
057: }
058:
059: /**
060: * Create a symmetric key seeded with the specified pass phrase
061: * This fellow creates a Rijndael 128 bit key
062: */
063: public static SymmetricKey createSymmetricKey(String passphrase) {
064: return createSymmetricKey("aes:128", passphrase);
065: }
066:
067: /**
068: * Make the passphrase into a fixed size byte array with smearing
069: */
070: public static byte[] bytesFromPassphrase(int len, String passphrase) {
071: byte[] key = new byte[len];
072: long seed = 13 * passphrase.length();
073: for (int i = 0; i < key.length; i++) {
074: int c = passphrase.charAt(i % passphrase.length());
075: seed += (c << 18) ^ c;
076: seed = (seed * 0x5DEECE66DL + 0xBL) & ((1L << 48) - 1);
077: key[i] = (byte) ((seed >> 5) & 0xff);
078: }
079: return key;
080: }
081:
082: /**
083: * Create a symmetric key from an algorithm specification and a pass
084: * phrase.
085: *
086: */
087: public static SymmetricKey createSymmetricKey(String algo,
088: String passphrase) {
089: SymmetricKey k = null;
090:
091: algo = algo.toLowerCase();
092: if (algo.startsWith("aes")) {
093: int len = 16;
094: int idx = algo.indexOf(':');
095: if (idx > 0) {
096: len = Integer.parseInt(algo.substring(idx + 1)) / 8;
097: }
098: Rijndael rk = new Rijndael();
099: rk.init(bytesFromPassphrase(len, passphrase));
100: k = rk;
101: } else if (algo.startsWith("tea:256")) {
102: Tea256 tk = new Tea256();
103: tk.init(bytesFromPassphrase(256, passphrase));
104: k = tk;
105: } else if (algo.startsWith("tea:128")) {
106: Tea tk = new Tea();
107: tk.init(bytesFromPassphrase(128, passphrase));
108: k = tk;
109: }
110: return k;
111: }
112:
113: /**
114: * Create a public/private key pair and return the private portion
115: */
116: public static PrivateKey createPrivateKey(Random r, String alg,
117: String name) {
118: RSAPrivateKey k = new RSAPrivateKey();
119: k.init(name, 1024, r);
120: return k;
121: }
122:
123: /**
124: * Restore a symmetric key from its serialized form
125: */
126: public static SymmetricKey readSymmetricKey(String s) {
127: Tea t = new Tea();
128: t.init(s);
129: return t;
130: }
131:
132: /**
133: * Restore a public key from its serialized form
134: */
135: public static PublicKey readPublicKey(String s) {
136: RSAPublicKey k = new RSAPublicKey();
137: k.init(s);
138: return k;
139: }
140:
141: /**
142: * Restore a private key from its serialized form
143: */
144: public static PrivateKey readPrivateKey(String s) {
145: RSAPrivateKey k = new RSAPrivateKey();
146: k.init(s);
147: return k;
148: }
149:
150: /**
151: * Create a digest
152: */
153: public static Digest createDigest(String alg) {
154: return new SHA1Digest();
155: }
156:
157: public static Random createRandom(String seed) {
158: Random r = new java.util.Random();
159: r.setSeed(System.currentTimeMillis() * 1003 + seed.hashCode());
160: return r;
161: }
162:
163: }
|