KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > com > quadcap > crypto > KeyFactory


1 package com.quadcap.crypto;
2
3 /* Copyright 2002 - 2003 Quadcap Software. All rights reserved.
4  *
5  * This software is distributed under the Quadcap Free Software License.
6  * This software may be used or modified for any purpose, personal or
7  * commercial. Open Source redistributions are permitted. Commercial
8  * redistribution of larger works derived from, or works which bundle
9  * this software requires a "Commercial Redistribution License"; see
10  * http://www.quadcap.com/purchase.
11  *
12  * Redistributions qualify as "Open Source" under one of the following terms:
13  *
14  * Redistributions are made at no charge beyond the reasonable cost of
15  * materials and delivery.
16  *
17  * Redistributions are accompanied by a copy of the Source Code or by an
18  * irrevocable offer to provide a copy of the Source Code for up to three
19  * years at the cost of materials and delivery. Such redistributions
20  * must allow further use, modification, and redistribution of the Source
21  * Code under substantially the same terms as this license.
22  *
23  * Redistributions of source code must retain the copyright notices as they
24  * appear in each source code file, these license terms, and the
25  * disclaimer/limitation of liability set forth as paragraph 6 below.
26  *
27  * Redistributions in binary form must reproduce this Copyright Notice,
28  * these license terms, and the disclaimer/limitation of liability set
29  * forth as paragraph 6 below, in the documentation and/or other materials
30  * provided with the distribution.
31  *
32  * The Software is provided on an "AS IS" basis. No warranty is
33  * provided that the Software is free of defects, or fit for a
34  * particular purpose.
35  *
36  * Limitation of Liability. Quadcap Software shall not be liable
37  * for any damages suffered by the Licensee or any third party resulting
38  * from use of the Software.
39  */
40
41 import java.util.Random JavaDoc;
42
43 /**
44  * A simple key factory to localize the (hardcoded) choice of ciphers.
45  *
46  * @author Stan Bailes
47  */
48 public class KeyFactory {
49     /**
50      * Create a symmetric key using the specified random number generator
51      * and the default symmetric key algorithm
52      */
53     public static SymmetricKey createSymmetricKey(Random JavaDoc r) {
54         SymmetricKey k = new Tea();
55         k.init(r);
56         return k;
57     }
58
59     /**
60      * Create a symmetric key seeded with the specified pass phrase
61      * This fellow creates a Rijndael 128 bit key
62      */
63     public static SymmetricKey createSymmetricKey(String JavaDoc passphrase) {
64         return createSymmetricKey("aes:128", passphrase);
65     }
66
67     /**
68      * Make the passphrase into a fixed size byte array with smearing
69      */
70     public static byte[] bytesFromPassphrase(int len, String JavaDoc passphrase) {
71         byte[] key = new byte[len];
72         long seed = 13 * passphrase.length();
73         for (int i = 0; i < key.length; i++) {
74             int c = passphrase.charAt(i % passphrase.length());
75             seed += (c << 18) ^ c;
76             seed = (seed * 0x5DEECE66DL + 0xBL) & ((1L << 48) - 1);
77             key[i] = (byte)((seed >> 5) & 0xff);
78         }
79         return key;
80     }
81
82     /**
83      * Create a symmetric key from an algorithm specification and a pass
84      * phrase.
85      *
86      */
87     public static SymmetricKey createSymmetricKey(String JavaDoc algo,
88                                                   String JavaDoc passphrase) {
89         SymmetricKey k = null;
90         
91         algo = algo.toLowerCase();
92         if (algo.startsWith("aes")) {
93             int len = 16;
94             int idx = algo.indexOf(':');
95             if (idx > 0) {
96                 len = Integer.parseInt(algo.substring(idx+1)) / 8;
97             }
98             Rijndael rk = new Rijndael();
99             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 JavaDoc r, String JavaDoc alg,
117                                               String JavaDoc 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 JavaDoc 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 JavaDoc 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 JavaDoc 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 JavaDoc alg) {
154         return new SHA1Digest();
155     }
156
157     public static Random JavaDoc createRandom(String JavaDoc seed) {
158         Random JavaDoc r = new java.util.Random JavaDoc();
159         r.setSeed(System.currentTimeMillis() * 1003 + seed.hashCode());
160         return r;
161     }
162
163 }
164
Popular Tags