001: /*
002: *
003: *
004: * Copyright 1990-2007 Sun Microsystems, Inc. All Rights Reserved.
005: * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER
006: *
007: * This program is free software; you can redistribute it and/or
008: * modify it under the terms of the GNU General Public License version
009: * 2 only, as published by the Free Software Foundation.
010: *
011: * This program is distributed in the hope that it will be useful, but
012: * WITHOUT ANY WARRANTY; without even the implied warranty of
013: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
014: * General Public License version 2 for more details (a copy is
015: * included at /legal/license.txt).
016: *
017: * You should have received a copy of the GNU General Public License
018: * version 2 along with this work; if not, write to the Free Software
019: * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
020: * 02110-1301 USA
021: *
022: * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
023: * Clara, CA 95054 or visit www.sun.com if you need additional
024: * information or have any questions.
025: */
026:
027: package com.sun.midp.crypto;
028:
029: /**
030: * This class defines some static utility methods.
031: */
032: public class Util {
033: // These are here only to support toString() methods in SecretKey
034: // and RSAKey
035: /** Hexadecimal character digits (0-f). */
036: private static char[] hc = { '0', '1', '2', '3', '4', '5', '6',
037: '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };
038:
039: /**
040: * Converts a byte array into a corresponding string of hexadecimal
041: * digits. This is equivalent to hexEncode(b, 0, b.length).
042: *
043: * @param b byte array to be converted
044: * @return corresponding hexadecimal string
045: */
046: static String hexEncode(byte[] b) {
047: if (b == null)
048: return ("");
049: else {
050: char[] r = new char[b.length << 1];
051: int v;
052: for (int i = 0, j = 0; i < b.length; i++) {
053: v = b[i] & 0xff;
054: r[j++] = hc[v >>> 4];
055: r[j++] = hc[v & 0x0f];
056: }
057: return (new String(r));
058: }
059: }
060:
061: /**
062: * Creates a copy of byte array.
063: * @param array the byte array to be copied
064: * @param offset where to begin
065: * @param len how many bytes to copy
066: * @return the copy of the array
067: */
068: public static byte[] cloneSubarray(byte[] array, int offset, int len) {
069: byte[] data = new byte[len];
070: System.arraycopy(array, 0, data, offset, len);
071: return data;
072: }
073:
074: /**
075: * Creates a copy of byte array.
076: * @param array the byte array to be copied
077: * @return the copy of the array
078: */
079: public static byte[] cloneArray(byte[] array) {
080: byte[] data = new byte[array.length];
081: System.arraycopy(array, 0, data, 0, array.length);
082: return data;
083: }
084:
085: /**
086: * Performs an XOR operation of arrays elements. Results are placed
087: * into the first array.
088: * @param a the first array
089: * @param b the second array
090: */
091: public static void xorArrays(byte[] a, byte[] b) {
092: for (int i = 0; i < a.length; i++) {
093: a[i] ^= b[i];
094: }
095: }
096:
097: /**
098: * Unpacks data from string representation.
099: * @param src packed data
100: * @return unpacked data
101: */
102: public static byte[] unpackBytes(String src) {
103:
104: byte[] data = src.getBytes();
105: int srcLen, len;
106:
107: byte[] res = new byte[len = ((srcLen = data.length) >> 3) * 7
108: + (srcLen & 7) - 1];
109:
110: int i = 0;
111: for (int k = len; k < srcLen; k++) {
112: int mask = data[k];
113: for (int j = 0; j < 7 && i < len; j++, i++) {
114: res[i] = ((mask & (1 << j)) == 0) ? data[i]
115: : (byte) (data[i] | 0x80);
116: }
117: }
118: return res;
119: }
120:
121: /**
122: * Returns 4 bytes from the buffer as integer value.
123: * @param data data array
124: * @param offset value offset
125: * @return the value
126: */
127: public static int getInt(byte[] data, int offset) {
128: int res = 0;
129: for (int i = 0; i < 4; i++) {
130: res = (res << 8) | (data[offset + i] & 0xff);
131: }
132: return res;
133: }
134:
135: /**
136: * Verifies that method parameters are correct.
137: * NOTE: This method accepts too big outputOffset values - cipher
138: * methods must throw ShortBufferException if there are output data.
139: * @param input the input buffer
140: * @param inputOffset the offset in <code>input</code> where the input
141: * starts
142: * @param inputLen the input length
143: * @param output the buffer for the result
144: * @param outputOffset the offset in <code>output</code> where the result
145: * is stored
146: * @throws IllegalArgumentException if parameters are wrong.
147: */
148: public static void checkBounds(byte[] input, int inputOffset,
149: int inputLen, byte[] output, int outputOffset) {
150:
151: if (inputLen != 0
152: && (input == null || inputOffset < 0 || inputLen < 0 || inputOffset
153: + inputLen > input.length)) {
154: throw new IllegalArgumentException("input out of bounds");
155: }
156:
157: if (output == null || outputOffset < 0) {
158: throw new IllegalArgumentException("output out of bounds");
159: }
160: }
161: }
|