001 /**
002 * Licensed to the Apache Software Foundation (ASF) under one or more
003 * contributor license agreements. See the NOTICE file distributed with
004 * this work for additional information regarding copyright ownership.
005 * The ASF licenses this file to You under the Apache License, Version 2.0
006 * (the "License"); you may not use this file except in compliance with
007 * the License. You may obtain a copy of the License at
008 *
009 * http://www.apache.org/licenses/LICENSE-2.0
010 *
011 * Unless required by applicable law or agreed to in writing, software
012 * distributed under the License is distributed on an "AS IS" BASIS,
013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014 * See the License for the specific language governing permissions and
015 * limitations under the License.
016 */
017
018 package org.apache.geronimo.crypto.encoders;
019
020 import java.io.ByteArrayOutputStream;
021 import java.io.IOException;
022 import java.io.OutputStream;
023
024 /**
025 * Convert binary data to and from UrlBase64 encoding. This is identical to
026 * Base64 encoding, except that the padding character is "." and the other
027 * non-alphanumeric characters are "-" and "_" instead of "+" and "/".
028 * <p>
029 * The purpose of UrlBase64 encoding is to provide a compact encoding of binary
030 * data that is safe for use as an URL parameter. Base64 encoding does not
031 * produce encoded values that are safe for use in URLs, since "/" can be
032 * interpreted as a path delimiter; "+" is the encoded form of a space; and
033 * "=" is used to separate a name from the corresponding value in an URL
034 * parameter.
035 */
036 public class UrlBase64
037 {
038 private static final Encoder encoder = new UrlBase64Encoder();
039
040 /**
041 * Encode the input data producing a URL safe base 64 encoded byte array.
042 *
043 * @return a byte array containing the URL safe base 64 encoded data.
044 */
045 public static byte[] encode(
046 byte[] data)
047 {
048 ByteArrayOutputStream bOut = new ByteArrayOutputStream();
049
050 try
051 {
052 encoder.encode(data, 0, data.length, bOut);
053 }
054 catch (IOException e)
055 {
056 throw new RuntimeException("exception encoding URL safe base64 string: " + e.getMessage(), e);
057 }
058
059 return bOut.toByteArray();
060 }
061
062 /**
063 * Encode the byte data writing it to the given output stream.
064 *
065 * @return the number of bytes produced.
066 */
067 public static int encode(
068 byte[] data,
069 OutputStream out)
070 throws IOException
071 {
072 return encoder.encode(data, 0, data.length, out);
073 }
074
075 /**
076 * Decode the URL safe base 64 encoded input data - white space will be ignored.
077 *
078 * @return a byte array representing the decoded data.
079 */
080 public static byte[] decode(
081 byte[] data)
082 {
083 ByteArrayOutputStream bOut = new ByteArrayOutputStream();
084
085 try
086 {
087 encoder.decode(data, 0, data.length, bOut);
088 }
089 catch (IOException e)
090 {
091 throw new RuntimeException("exception decoding URL safe base64 string: " + e.getMessage(), e);
092 }
093
094 return bOut.toByteArray();
095 }
096
097 /**
098 * decode the URL safe base 64 encoded byte data writing it to the given output stream,
099 * whitespace characters will be ignored.
100 *
101 * @return the number of bytes produced.
102 */
103 public static int decode(
104 byte[] data,
105 OutputStream out)
106 throws IOException
107 {
108 return encoder.decode(data, 0, data.length, out);
109 }
110
111 /**
112 * decode the URL safe base 64 encoded String data - whitespace will be ignored.
113 *
114 * @return a byte array representing the decoded data.
115 */
116 public static byte[] decode(
117 String data)
118 {
119 ByteArrayOutputStream bOut = new ByteArrayOutputStream();
120
121 try
122 {
123 encoder.decode(data, bOut);
124 }
125 catch (IOException e)
126 {
127 throw new RuntimeException("exception decoding URL safe base64 string: " + e.getMessage(), e);
128 }
129
130 return bOut.toByteArray();
131 }
132
133 /**
134 * Decode the URL safe base 64 encoded String data writing it to the given output stream,
135 * whitespace characters will be ignored.
136 *
137 * @return the number of bytes produced.
138 */
139 public static int decode(
140 String data,
141 OutputStream out)
142 throws IOException
143 {
144 return encoder.decode(data, out);
145 }
146 }