I have an image that is Base64 encoded. What is the best way to decode that in Java? Hopefully using only the libraries included with Sun Java 6.
-
2Here is yet another implementation I recently through together: https://github.com/n1hility/playground/blob/master/src/main/java/org/jboss/FlexBase64.java – Jason Greene Nov 12 '12 at 18:37
-
3Note that if you are developing an Android app, Google has already done this: http://developer.android.com/reference/android/util/Base64.html – Raphael Oliveira Feb 04 '13 at 17:26
-
1No matter what type of app your using (experiment or not), it's just as simple as creating a single Base64.java file in your utils package using the code here: http://migbase64.sourceforge.net/ Look at the performance charts and notice the difference: 4-5 times as fast. – javacoder Mar 26 '10 at 01:44
-
FYI: [JEP 135](http://openjdk.java.net/jeps/135) proposes to introduce a standard, discoverable API for this in the Java platform. – Jesse Glick Mar 03 '12 at 00:57
-
Progress happening: http://mail.openjdk.java.net/pipermail/core-libs-dev/2012-October/011722.html – JodaStephen Oct 11 '12 at 09:47
21 Answers
As of Java 8, there is an officially supported API for Base64 encoding and decoding. In time this will probably become the default choice.
The API includes the class java.util.Base64
and its nested classes. It supports three different flavors: basic, URL safe, and MIME.
Sample code using the "basic" encoding:
import java.util.Base64;
byte[] bytes = "Hello, World!".getBytes("UTF-8");
String encoded = Base64.getEncoder().encodeToString(bytes);
byte[] decoded = Base64.getDecoder().decode(encoded);
String decodedStr = new String(decoded, StandardCharsets.UTF_8);
The documentation for java.util.Base64
includes several more methods for configuring encoders and decoders, and for using different classes as inputs and outputs (byte arrays, strings, ByteBuffers, java.io streams).

- 5,941
- 2
- 43
- 58

- 12,296
- 4
- 32
- 39
-
1I am using Java 8. Is this the recommended approach if using Java 8? – JohnMerlino Jun 24 '14 at 20:52
-
4@JohnMerlino if compatibility with older Java versions is not required, I would recommend using this API as the JRE has a stronger compatibility policy than most libraries. Also, being included in the JRE, it doesn't constrain your dependencies in any possible way. – Andrea Jun 25 '14 at 10:56
-
4
-
1Almost good: this only accepts raw base64 streams, not base64 files. I had to use `final byte[] decoded = Base64.getMimeDecoder().decode(encoded);` instead. But thanks anyway! (Nice with commons-io `FileUtils.readFileToByteArray` and `FileUtils.writeByteArrayToFile` – especially when you realise `encoded` can be a `byte[]` as well.) – mirabilos Jul 21 '16 at 17:22
As of v6, Java SE ships with JAXB. javax.xml.bind.DatatypeConverter
has static methods that make this easy. See parseBase64Binary()
and printBase64Binary()
.
UPDATE: JAXB is no longer shipped with Java (since Java 11). If JAXB is required for your project, you will need to configure the relevant libraries via your dependency management system, for example Maven. If you require the compiler (xjc.exe
) you also need to download that separately.

- 5,774
- 2
- 25
- 37

- 11,544
- 3
- 36
- 36
-
20However, it seems that the `printBase64Binary(..)` method doesn't do the MIME version of Base64 ( http://en.wikipedia.org/wiki/Base64#MIME ), while the private Sun and the Commons implementations use this. Specifically, for String bigger than 76 characters, newlines are added. I didn't find how to configure JAXB's implementation for this behavior... :-( – KLE Mar 18 '10 at 10:25
-
7however, the sun implementation will ignore newlines. So they are compatible. – Esben Skov Pedersen Apr 20 '10 at 09:52
-
1Actually isn't inclusion of Linefeeds the standard way; and not adding (theoretically) non-compliant? – StaxMan Jul 05 '13 at 18:27
-
9Warning! parseBase64Binary will silently skip over invalid characters and will not check for the base64 validity. It is better to use Commons Codec or Guava Base64. Note that Guava rejects newlines and whitespace characters, so you need to parse strings with whitespaces omitted: BaseEncoding.base64().decode(s.replaceAll("\\s", "")) – Martin Vysny Jul 22 '13 at 11:09
-
10Be careful. This function does not work with data longer than 65000. (java version 1.6) – Huseyin Yagli Sep 21 '13 at 14:35
-
1@Hüseyin Yağlı: that's not true, I tested with a byte array of 100MB and it worked. Where did you get this information? – dmoebius Jan 15 '14 at 16:29
-
@dmoebius In an applet I wrote using Java SDK 1.6, I used parseBase64Binary() and it always crashed with data larger than 64K and worked fine with smaller data. You might be using a newer version of Java SDK. – Huseyin Yagli Jan 16 '14 at 10:08
-
2Please, be careful when using the parseBase64Binary() : When it calculates the `byte` array size with the [`guessLength`](http://grepcode.com/file/repository.grepcode.com/java/root/jdk/openjdk/6-b27/javax/xml/bind/DatatypeConverterImpl.java#DatatypeConverterImpl.guessLength%28java.lang.String%29) function, the value can be inferior to the `String` length. So when looping through the `String` characters, we can get an `ArrayOutOfBoundException`. As stated by the others, use `org.apache.commons.codec.binary.Base64` as it doesn't compute the output `byte` array size. – Zakaria Jul 07 '17 at 15:13
-
7Don't use it, because you will get problems in jdk 9: java.lang.NoClassDefFoundError(javax/xml/bind/DatatypeConverter) – rupashka Aug 10 '17 at 14:01
-
@MartinVysny as of 1.9 commons codec also skips over illegal characters following the "garbage in/garbage out" philosophy. Bad for security. Requires to first use isBase64 and as such the data must be read twice. – Harald Sep 23 '17 at 20:42
No need to use commons--Sun ships a base64 encoder with Java. You can import it as such:
import sun.misc.BASE64Decoder;
And then use it like this:
BASE64Decoder decoder = new BASE64Decoder();
byte[] decodedBytes = decoder.decodeBuffer(encodedBytes);
Where encodedBytes
is either a java.lang.String
or a java.io.InputStream
. Just beware that the sun.*
classes are not "officially supported" by Sun.
EDIT: Who knew this would be the most controversial answer I'd ever post? I do know that sun.* packages are not supported or guaranteed to continue existing, and I do know about Commons and use it all the time. However, the poster asked for a class that that was "included with Sun Java 6," and that's what I was trying to answer. I agree that Commons is the best way to go in general.
EDIT 2: As amir75 points out below, Java 6+ ships with JAXB, which contains supported code to encode/decode Base64. Please see Jeremy Ross' answer below.
-
198-1 - this is internal Sun code, is NOT part of J2SE (it, not portable), and may disappear at any time -- Sun explicitly says to NOT use their internal libraries in user code – kdgregory Jan 22 '09 at 16:08
-
60
-
The main issue is the consequence of your disclaimer: the class can be removed, the package name can change... silently. – Nicolas Jan 22 '09 at 16:15
-
2Right, it's a toss-up between short-term expedience and long-term maintainability. It's included with Java 6, which is what the poster asked about, though it could certainly go away in a later rev of Java 6. If that happens, I'd agree that Commons should be used in its place. – MattK Jan 22 '09 at 16:17
-
21This is for a short term project and is just a experiment and don't want to go through the process of approval for a new library. So this is the correct answer to this question. – Ryan P Jan 22 '09 at 16:23
-
45Bzzt. In a professional environment, using an unsupported, undocumented feature is never the correct decision. And in a corporate environment, "experiments" become "production code" with no chance to fix the hacks. – kdgregory Jan 22 '09 at 17:03
-
29In a research department where that code is marked as experiment and when it is marked always gets scrapped it is the correct decision. – Ryan P Jan 22 '09 at 20:17
-
12sun.misc.BASE64Decoder has been shipped with the JRE since at least 1.1. Why won't sun just put it (and BASE64Encoder) in the java.util package? – Jason Day May 14 '09 at 20:30
-
No idea, Jason. There's four or five other implementations in the JDK. Perhaps JDK7? – Tom Hawtin - tackline May 14 '09 at 21:04
-
We just had the same trouble using getBytes() -> toString() and lost some (not all) byte-values during conversion. Pointing us to Base64 classes (we used the Apache implementation) with it's encode/decode methods saved our day. – Gerhard Dinhof Feb 25 '10 at 11:21
-
3@Jason: You're not the first with that idea, it has been submitted 11 (!!) years ago: http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=4235519 – Kees Kist Sep 07 '10 at 10:23
-
16@Ryan P: While this answer may be the best for you in a your situation (throwaway experimental code for research), and thus this answer is correct for you, your question doesn't make it explicit that you are in a non-production context... and this answer may mislead others who don't read all the comments to the answer. It may be best to clarify your question with your constraints, so they are more visible. As it stands, your question is "What is the best way to decode that [base64] in Java?" - and using sun.misc.BASE64Decoder is not the correct answer to that general question. – Colin K Jan 18 '11 at 22:45
-
5Java6+ users should scroll down to the JAXB answer below. No need for sun-specific classes :) – laher Sep 06 '11 at 00:44
-
1@amir75 - Thanks for bringing that to my attention. I've edited my answer to include a pointer to the JAXB answer. – MattK Sep 06 '11 at 14:06
-
1I've posted my answer to include Joshua Bloch's implementation of the Base 64 algorithm (found under `java.util.prefs.Base64`). I know it's late but, I thought this would be very relevant. – Buhake Sindi Sep 26 '11 at 05:39
-
3
-
downvoted for use of internal Sun code. The Apache Commons Codec library has a Base64 encoder/decoder. – Michael Feb 13 '13 at 23:01
-
I was using same code but doing a minor mistake of passing decoded value instead of encoded one – Soman Dubey Sep 18 '13 at 09:45
-
Even if your answer is what the user is looking for, I downvote it to discourage its use by everyone else looking for this same question. – Roberto Linares Jun 03 '14 at 16:06
-
Downvoted for use of private package and because as of Java 9 (and project jigsaw) you won't be able to use this private code anymore without JVM arguments. – eskatos Jul 20 '15 at 10:18
-
1@eskatos, the question is about using only the libraries included with *Sun Java 6*. – Sebastian Nov 06 '15 at 02:06
-
-
Access restriction: The type 'BASE64Decoder' is not API restriction on required library. Long gone from Java 7. – Pratik Gaurav Jul 22 '22 at 07:46
Specifically in Commons Codec: class Base64
to decode(byte[] array)
or encode(byte[] array)

- 553
- 3
- 9

- 161,610
- 92
- 305
- 395
-
7You can link the text 'Commons Codec' to the project page. That way this answer would be better than Kevin's :) – mmutilva Jun 02 '09 at 17:19
-
1I know this is an old question, but Why isn't this the accepted answer? Isn't the commons codec included with most java installations, and far fewer lines of code to use than rolling your own version? – Li Haoyi Apr 05 '12 at 14:22
-
2@LiHaoyi The question asked for libraries that shipped with Sun's JDK, which does not include anything from the Commons. – Ti Strga Feb 26 '13 at 15:53
-
1
Guava now has Base64 decoding built in.
Use BaseEncoding.base64().decode()
As for dealing with possible whitespace in input use
BaseEncoding.base64().decode(CharMatcher.WHITESPACE.removeFrom(...));
See this discussion for more information

- 10,241
- 6
- 46
- 71
-
1Guava 14 is still a release candidate, but this still gets my upvote -- by the time it reaches any decent position it should be golden :-) – Peter Becker Jan 09 '13 at 03:34
-
1Guava base64 decoder rejects newline and space characters so you have to remove them beforehand. – Martin Vysny Jul 22 '13 at 11:26
My solution is fastest and easiest.
public class MyBase64 {
private final static char[] ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".toCharArray();
private static int[] toInt = new int[128];
static {
for(int i=0; i< ALPHABET.length; i++){
toInt[ALPHABET[i]]= i;
}
}
/**
* Translates the specified byte array into Base64 string.
*
* @param buf the byte array (not null)
* @return the translated Base64 string (not null)
*/
public static String encode(byte[] buf){
int size = buf.length;
char[] ar = new char[((size + 2) / 3) * 4];
int a = 0;
int i=0;
while(i < size){
byte b0 = buf[i++];
byte b1 = (i < size) ? buf[i++] : 0;
byte b2 = (i < size) ? buf[i++] : 0;
int mask = 0x3F;
ar[a++] = ALPHABET[(b0 >> 2) & mask];
ar[a++] = ALPHABET[((b0 << 4) | ((b1 & 0xFF) >> 4)) & mask];
ar[a++] = ALPHABET[((b1 << 2) | ((b2 & 0xFF) >> 6)) & mask];
ar[a++] = ALPHABET[b2 & mask];
}
switch(size % 3){
case 1: ar[--a] = '=';
case 2: ar[--a] = '=';
}
return new String(ar);
}
/**
* Translates the specified Base64 string into a byte array.
*
* @param s the Base64 string (not null)
* @return the byte array (not null)
*/
public static byte[] decode(String s){
int delta = s.endsWith( "==" ) ? 2 : s.endsWith( "=" ) ? 1 : 0;
byte[] buffer = new byte[s.length()*3/4 - delta];
int mask = 0xFF;
int index = 0;
for(int i=0; i< s.length(); i+=4){
int c0 = toInt[s.charAt( i )];
int c1 = toInt[s.charAt( i + 1)];
buffer[index++]= (byte)(((c0 << 2) | (c1 >> 4)) & mask);
if(index >= buffer.length){
return buffer;
}
int c2 = toInt[s.charAt( i + 2)];
buffer[index++]= (byte)(((c1 << 4) | (c2 >> 2)) & mask);
if(index >= buffer.length){
return buffer;
}
int c3 = toInt[s.charAt( i + 3 )];
buffer[index++]= (byte)(((c2 << 6) | c3) & mask);
}
return buffer;
}
}

- 481
- 4
- 2
-
15it is not buggy! - read the javadoc comments... the parameter of decode(..) is *base64* String not just any String. `byte[] b1 = {1,2,3}; byte[] b2 = decode(encode(b1)); System.out.println(Arrays.equals( b1, b2 ));` // => true – GeorgeK May 05 '11 at 14:23
-
10
-
7I ran some tests comparing this class with commons-codec and it seems to work OK. I needed something simple like this because I only needed base64 encoding and didn't want all the extra stuff that commons-codec provides, thanks. – Michael Jul 22 '13 at 16:31
-
2Is this trustful? It seems to be the easiest if you don't want to import external libraries. – Felipe Oct 22 '13 at 20:53
-
2
-
Seems to be from here: http://www.java2s.com/Code/Java/File-Input-Output/Base64encodedecodedatausingtheBase64encodingscheme.htm – dforce May 04 '16 at 09:25
-
1How silly. Why is it easier to reinvent a routine that is readily available in the standard runtime libraries? How do you know it is faster than the library implementation? If it is, you should submit your code to replace the library implementation, and help the Community. – BobDoolittle Feb 09 '17 at 18:11
Here's my own implementation, if it could be useful to someone :
public class Base64Coder {
// The line separator string of the operating system.
private static final String systemLineSeparator = System.getProperty("line.separator");
// Mapping table from 6-bit nibbles to Base64 characters.
private static final char[] map1 = new char[64];
static {
int i=0;
for (char c='A'; c<='Z'; c++) map1[i++] = c;
for (char c='a'; c<='z'; c++) map1[i++] = c;
for (char c='0'; c<='9'; c++) map1[i++] = c;
map1[i++] = '+'; map1[i++] = '/'; }
// Mapping table from Base64 characters to 6-bit nibbles.
private static final byte[] map2 = new byte[128];
static {
for (int i=0; i<map2.length; i++) map2[i] = -1;
for (int i=0; i<64; i++) map2[map1[i]] = (byte)i; }
/**
* Encodes a string into Base64 format.
* No blanks or line breaks are inserted.
* @param s A String to be encoded.
* @return A String containing the Base64 encoded data.
*/
public static String encodeString (String s) {
return new String(encode(s.getBytes())); }
/**
* Encodes a byte array into Base 64 format and breaks the output into lines of 76 characters.
* This method is compatible with <code>sun.misc.BASE64Encoder.encodeBuffer(byte[])</code>.
* @param in An array containing the data bytes to be encoded.
* @return A String containing the Base64 encoded data, broken into lines.
*/
public static String encodeLines (byte[] in) {
return encodeLines(in, 0, in.length, 76, systemLineSeparator); }
/**
* Encodes a byte array into Base 64 format and breaks the output into lines.
* @param in An array containing the data bytes to be encoded.
* @param iOff Offset of the first byte in <code>in</code> to be processed.
* @param iLen Number of bytes to be processed in <code>in</code>, starting at <code>iOff</code>.
* @param lineLen Line length for the output data. Should be a multiple of 4.
* @param lineSeparator The line separator to be used to separate the output lines.
* @return A String containing the Base64 encoded data, broken into lines.
*/
public static String encodeLines (byte[] in, int iOff, int iLen, int lineLen, String lineSeparator) {
int blockLen = (lineLen*3) / 4;
if (blockLen <= 0) throw new IllegalArgumentException();
int lines = (iLen+blockLen-1) / blockLen;
int bufLen = ((iLen+2)/3)*4 + lines*lineSeparator.length();
StringBuilder buf = new StringBuilder(bufLen);
int ip = 0;
while (ip < iLen) {
int l = Math.min(iLen-ip, blockLen);
buf.append (encode(in, iOff+ip, l));
buf.append (lineSeparator);
ip += l; }
return buf.toString(); }
/**
* Encodes a byte array into Base64 format.
* No blanks or line breaks are inserted in the output.
* @param in An array containing the data bytes to be encoded.
* @return A character array containing the Base64 encoded data.
*/
public static char[] encode (byte[] in) {
return encode(in, 0, in.length); }
/**
* Encodes a byte array into Base64 format.
* No blanks or line breaks are inserted in the output.
* @param in An array containing the data bytes to be encoded.
* @param iLen Number of bytes to process in <code>in</code>.
* @return A character array containing the Base64 encoded data.
*/
public static char[] encode (byte[] in, int iLen) {
return encode(in, 0, iLen); }
/**
* Encodes a byte array into Base64 format.
* No blanks or line breaks are inserted in the output.
* @param in An array containing the data bytes to be encoded.
* @param iOff Offset of the first byte in <code>in</code> to be processed.
* @param iLen Number of bytes to process in <code>in</code>, starting at <code>iOff</code>.
* @return A character array containing the Base64 encoded data.
*/
public static char[] encode (byte[] in, int iOff, int iLen) {
int oDataLen = (iLen*4+2)/3; // output length without padding
int oLen = ((iLen+2)/3)*4; // output length including padding
char[] out = new char[oLen];
int ip = iOff;
int iEnd = iOff + iLen;
int op = 0;
while (ip < iEnd) {
int i0 = in[ip++] & 0xff;
int i1 = ip < iEnd ? in[ip++] & 0xff : 0;
int i2 = ip < iEnd ? in[ip++] & 0xff : 0;
int o0 = i0 >>> 2;
int o1 = ((i0 & 3) << 4) | (i1 >>> 4);
int o2 = ((i1 & 0xf) << 2) | (i2 >>> 6);
int o3 = i2 & 0x3F;
out[op++] = map1[o0];
out[op++] = map1[o1];
out[op] = op < oDataLen ? map1[o2] : '='; op++;
out[op] = op < oDataLen ? map1[o3] : '='; op++; }
return out; }
/**
* Decodes a string from Base64 format.
* No blanks or line breaks are allowed within the Base64 encoded input data.
* @param s A Base64 String to be decoded.
* @return A String containing the decoded data.
* @throws IllegalArgumentException If the input is not valid Base64 encoded data.
*/
public static String decodeString (String s) {
return new String(decode(s)); }
/**
* Decodes a byte array from Base64 format and ignores line separators, tabs and blanks.
* CR, LF, Tab and Space characters are ignored in the input data.
* This method is compatible with <code>sun.misc.BASE64Decoder.decodeBuffer(String)</code>.
* @param s A Base64 String to be decoded.
* @return An array containing the decoded data bytes.
* @throws IllegalArgumentException If the input is not valid Base64 encoded data.
*/
public static byte[] decodeLines (String s) {
char[] buf = new char[s.length()];
int p = 0;
for (int ip = 0; ip < s.length(); ip++) {
char c = s.charAt(ip);
if (c != ' ' && c != '\r' && c != '\n' && c != '\t')
buf[p++] = c; }
return decode(buf, 0, p); }
/**
* Decodes a byte array from Base64 format.
* No blanks or line breaks are allowed within the Base64 encoded input data.
* @param s A Base64 String to be decoded.
* @return An array containing the decoded data bytes.
* @throws IllegalArgumentException If the input is not valid Base64 encoded data.
*/
public static byte[] decode (String s) {
return decode(s.toCharArray()); }
/**
* Decodes a byte array from Base64 format.
* No blanks or line breaks are allowed within the Base64 encoded input data.
* @param in A character array containing the Base64 encoded data.
* @return An array containing the decoded data bytes.
* @throws IllegalArgumentException If the input is not valid Base64 encoded data.
*/
public static byte[] decode (char[] in) {
return decode(in, 0, in.length); }
/**
* Decodes a byte array from Base64 format.
* No blanks or line breaks are allowed within the Base64 encoded input data.
* @param in A character array containing the Base64 encoded data.
* @param iOff Offset of the first character in <code>in</code> to be processed.
* @param iLen Number of characters to process in <code>in</code>, starting at <code>iOff</code>.
* @return An array containing the decoded data bytes.
* @throws IllegalArgumentException If the input is not valid Base64 encoded data.
*/
public static byte[] decode (char[] in, int iOff, int iLen) {
if (iLen%4 != 0) throw new IllegalArgumentException ("Length of Base64 encoded input string is not a multiple of 4.");
while (iLen > 0 && in[iOff+iLen-1] == '=') iLen--;
int oLen = (iLen*3) / 4;
byte[] out = new byte[oLen];
int ip = iOff;
int iEnd = iOff + iLen;
int op = 0;
while (ip < iEnd) {
int i0 = in[ip++];
int i1 = in[ip++];
int i2 = ip < iEnd ? in[ip++] : 'A';
int i3 = ip < iEnd ? in[ip++] : 'A';
if (i0 > 127 || i1 > 127 || i2 > 127 || i3 > 127)
throw new IllegalArgumentException ("Illegal character in Base64 encoded data.");
int b0 = map2[i0];
int b1 = map2[i1];
int b2 = map2[i2];
int b3 = map2[i3];
if (b0 < 0 || b1 < 0 || b2 < 0 || b3 < 0)
throw new IllegalArgumentException ("Illegal character in Base64 encoded data.");
int o0 = ( b0 <<2) | (b1>>>4);
int o1 = ((b1 & 0xf)<<4) | (b2>>>2);
int o2 = ((b2 & 3)<<6) | b3;
out[op++] = (byte)o0;
if (op<oLen) out[op++] = (byte)o1;
if (op<oLen) out[op++] = (byte)o2; }
return out; }
// Dummy constructor.
private Base64Coder() {}
}

- 71,077
- 30
- 176
- 213
As an alternative to sun.misc.BASE64Decoder
or non-core libraries, look at javax.mail.internet.MimeUtility.decode()
.
public static byte[] encode(byte[] b) throws Exception {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
OutputStream b64os = MimeUtility.encode(baos, "base64");
b64os.write(b);
b64os.close();
return baos.toByteArray();
}
public static byte[] decode(byte[] b) throws Exception {
ByteArrayInputStream bais = new ByteArrayInputStream(b);
InputStream b64is = MimeUtility.decode(bais, "base64");
byte[] tmp = new byte[b.length];
int n = b64is.read(tmp);
byte[] res = new byte[n];
System.arraycopy(tmp, 0, res, 0, n);
return res;
}

- 81,827
- 26
- 193
- 197

- 34,977
- 11
- 70
- 85
Another late answer, but my benchmarking shows that Jetty's implementation of Base64 encoder is pretty fast. Not as fast as MiGBase64 but faster than iHarder Base64.
import org.eclipse.jetty.util.B64Code;
final String decoded = B64Code.decode(encoded, "UTF-8");
I also did some benchmarks:
library | encode | decode
------------------+--------------+-------------
'MiGBase64' | 10146001.00 | 6426446.00
'Jetty B64Code' | 8846191.00 | 3101361.75
'iHarder Base64' | 3259590.50 | 2505280.00
'Commons-Codec' | 241318.04 | 255179.96
These are runs/sec so higher is better.

- 30,900
- 8
- 101
- 128
Given a test encode/decode example of javax.xml.bind.DatatypeConverter using methods parseBase64Binary() and printBase64Binary() referring to @jeremy-ross and @nightfirecat answer.
@Test
public void EncodeDecode() {
//ENCODE
String hello = "Hello World";
byte[] helloBytes = hello.getBytes(StandardCharsets.UTF_8);
String encodedHello = DatatypeConverter.printBase64Binary(helloBytes);
LOGGER.info(hello + " encoded=> " + encodedHello);
//DECODE
byte[] encodedHelloBytes = DatatypeConverter.parseBase64Binary(encodedHello);
String helloAgain = new String(encodedHelloBytes, StandardCharsets.UTF_8) ;
LOGGER.info(encodedHello + " decoded=> " + helloAgain);
Assert.assertEquals(hello, helloAgain);
}
Result:
INFO - Hello World encoded=> SGVsbG8gV29ybGQ=
INFO - SGVsbG8gV29ybGQ= decoded=> Hello World

- 1,560
- 1
- 14
- 20
If You are prefering performance based solution then you can use "MiGBase64"
http://migbase64.sourceforge.net/
public class Base64Test {
public static void main(String[] args) {
String encodeToString = Base64.encodeToString("JavaTips.net".getBytes(), true);
System.out.println("encodeToString " + encodeToString);
byte[] decodedBytes = Base64.decode(encodeToString.getBytes());
System.out.println("decodedBytes " + new String(decodedBytes));
}
}

- 170,088
- 45
- 397
- 571
-
MiGBase64 is easy to use, well coded and blazing fast. Nice find, Imby. – mukama Jul 08 '12 at 07:10
-
According to [this benchmark](http://redd.it/17q18m) MiGBase64 is not the fastest implementation anymore, and now it lags behind both Apache Commons and sun.misc.BASE64Decoder significantly. – Andrea Mar 22 '13 at 22:13
Using Java 8 -
public static String encodeString(String plainString) {
return Base64.getEncoder().encodeToString(plainString.getBytes());
}
public static String decodeString(String encodedString) {
byte[] bytes = Base64.getDecoder().decode(encodedString);
return new String(bytes);
}

- 6,801
- 5
- 32
- 55
This is a late answer, but Joshua Bloch committed his Base64
class (when he was working for Sun, ahem, Oracle) under the java.util.prefs
package. This class existed since JDK 1.4.
E.g.
String currentString = "Hello World";
String base64String = java.util.prefs.Base64.byteArrayToBase64(currentString.getBytes("UTF-8"));

- 87,898
- 29
- 167
- 228
-
11Unfortunately the Base64 class has default visibility, so it's hardly public API. – glyn Oct 20 '11 at 15:02
-
2Why not just refer to [`java.util.Base64`](http://docs.oracle.com/javase/8/docs/api/java/util/Base64.html) – Lukas Eder Apr 30 '14 at 12:18
-
@LukasEder, that's because [`java.util.Base64`](http://docs.oracle.com/javase/8/docs/api/java/util/Base64.html) was released in JDK 8 (and higher). It doesn't exist on earlier releases. – Buhake Sindi Apr 30 '14 at 12:30
Hope this helps you:
import com.sun.org.apache.xml.internal.security.utils.Base64;
String str="Hello World";
String base64_str=Base64.encode(str.getBytes("UTF-8"));
Or:
String str="Hello World";
String base64_str="";
try
{base64_str=(String)Class.forName("java.util.prefs.Base64").getDeclaredMethod("byteArrayToBase64", new Class[]{byte[].class}).invoke(null, new Object[]{str.getBytes("UTF-8")});
}
catch (Exception ee) {}
java.util.prefs.Base64
works on local rt.jar
,
But it is not in The JRE Class White List
and not in Available classes not listed in the GAE/J white-list
What a pity!
PS. In android, it's easy because that android.util.Base64
has been included since Android API Level 8.
You can write or download file from encoded Base64 string:
Base64 base64 = new Base64();
String encodedFile="JVBERi0xLjUKJeLjz9MKMSAwIG9iago8PCAKICAgL1R5cGUgL0NhdGFsb2cKICAgL1BhZ2VzIDIgMCBSCiAgIC9QYWdlTGF5b3V0IC9TaW5";
byte[] dd=encodedFile.getBytes();
byte[] bytes = Base64.decodeBase64(dd);
response.setHeader("Content-disposition", "attachment; filename=\""+filename+"\"");
response.setHeader("Cache-Control", "no-cache");
response.setHeader("Expires", "-1");
// actually send result bytes
response.getOutputStream().write(bytes);
Worked for me and hopefully for you also...

- 672
- 12
- 16
The Java 8 implementation of java.util.Base64
has no dependencies on other Java 8 specific classes.
I am not certain if this will work for Java 6 project, but it is possible to copy and paste the Base64.java
file into a Java 7 project and compile it with no modification other than importing java.util.Arrays and java.util.Objects
.
Note the Base64.java file is covered by the GNU GPL2
I used android.util.base64
that works pretty good without any dependances:
Usage:
byte[] decodedKey = Base64.decode(encodedPublicKey, Base64.DEFAULT);
package com.test;
import java.io.UnsupportedEncodingException;
/**
* Utilities for encoding and decoding the Base64 representation of
* binary data. See RFCs <a
* href="http://www.ietf.org/rfc/rfc2045.txt">2045</a> and <a
* href="http://www.ietf.org/rfc/rfc3548.txt">3548</a>.
*/
public class Base64 {
public static final int DEFAULT = 0;
public static final int NO_PADDING = 1;
public static final int NO_WRAP = 2;
public static final int CRLF = 4;
public static final int URL_SAFE = 8;
public static final int NO_CLOSE = 16;
// --------------------------------------------------------
// shared code
// --------------------------------------------------------
/* package */ static abstract class Coder {
public byte[] output;
public int op;
public abstract boolean process(byte[] input, int offset, int len, boolean finish);
public abstract int maxOutputSize(int len);
}
// --------------------------------------------------------
// decoding
// --------------------------------------------------------
public static byte[] decode(String str, int flags) {
return decode(str.getBytes(), flags);
}
public static byte[] decode(byte[] input, int flags) {
return decode(input, 0, input.length, flags);
}
public static byte[] decode(byte[] input, int offset, int len, int flags) {
// Allocate space for the most data the input could represent.
// (It could contain less if it contains whitespace, etc.)
Decoder decoder = new Decoder(flags, new byte[len*3/4]);
if (!decoder.process(input, offset, len, true)) {
throw new IllegalArgumentException("bad base-64");
}
// Maybe we got lucky and allocated exactly enough output space.
if (decoder.op == decoder.output.length) {
return decoder.output;
}
// Need to shorten the array, so allocate a new one of the
// right size and copy.
byte[] temp = new byte[decoder.op];
System.arraycopy(decoder.output, 0, temp, 0, decoder.op);
return temp;
}
static class Decoder extends Coder {
private static final int DECODE[] = {
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, -1, 63,
52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, -2, -1, -1,
-1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1,
-1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
};
/**
* Decode lookup table for the "web safe" variant (RFC 3548
* sec. 4) where - and _ replace + and /.
*/
private static final int DECODE_WEBSAFE[] = {
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1,
52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, -2, -1, -1,
-1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, 63,
-1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
};
/** Non-data values in the DECODE arrays. */
private static final int SKIP = -1;
private static final int EQUALS = -2;
private int state; // state number (0 to 6)
private int value;
final private int[] alphabet;
public Decoder(int flags, byte[] output) {
this.output = output;
alphabet = ((flags & URL_SAFE) == 0) ? DECODE : DECODE_WEBSAFE;
state = 0;
value = 0;
}
public int maxOutputSize(int len) {
return len * 3/4 + 10;
}
/**
* Decode another block of input data.
*
* @return true if the state machine is still healthy. false if
* bad base-64 data has been detected in the input stream.
*/
public boolean process(byte[] input, int offset, int len, boolean finish) {
if (this.state == 6) return false;
int p = offset;
len += offset;
int state = this.state;
int value = this.value;
int op = 0;
final byte[] output = this.output;
final int[] alphabet = this.alphabet;
while (p < len) {
if (state == 0) {
while (p+4 <= len &&
(value = ((alphabet[input[p] & 0xff] << 18) |
(alphabet[input[p+1] & 0xff] << 12) |
(alphabet[input[p+2] & 0xff] << 6) |
(alphabet[input[p+3] & 0xff]))) >= 0) {
output[op+2] = (byte) value;
output[op+1] = (byte) (value >> 8);
output[op] = (byte) (value >> 16);
op += 3;
p += 4;
}
if (p >= len) break;
}
int d = alphabet[input[p++] & 0xff];
switch (state) {
case 0:
if (d >= 0) {
value = d;
++state;
} else if (d != SKIP) {
this.state = 6;
return false;
}
break;
case 1:
if (d >= 0) {
value = (value << 6) | d;
++state;
} else if (d != SKIP) {
this.state = 6;
return false;
}
break;
case 2:
if (d >= 0) {
value = (value << 6) | d;
++state;
} else if (d == EQUALS) {
// Emit the last (partial) output tuple;
// expect exactly one more padding character.
output[op++] = (byte) (value >> 4);
state = 4;
} else if (d != SKIP) {
this.state = 6;
return false;
}
break;
case 3:
if (d >= 0) {
// Emit the output triple and return to state 0.
value = (value << 6) | d;
output[op+2] = (byte) value;
output[op+1] = (byte) (value >> 8);
output[op] = (byte) (value >> 16);
op += 3;
state = 0;
} else if (d == EQUALS) {
// Emit the last (partial) output tuple;
// expect no further data or padding characters.
output[op+1] = (byte) (value >> 2);
output[op] = (byte) (value >> 10);
op += 2;
state = 5;
} else if (d != SKIP) {
this.state = 6;
return false;
}
break;
case 4:
if (d == EQUALS) {
++state;
} else if (d != SKIP) {
this.state = 6;
return false;
}
break;
case 5:
if (d != SKIP) {
this.state = 6;
return false;
}
break;
}
}
if (!finish) {
// We're out of input, but a future call could provide
// more.
this.state = state;
this.value = value;
this.op = op;
return true;
}
switch (state) {
case 0:
break;
case 1:
this.state = 6;
return false;
case 2:
output[op++] = (byte) (value >> 4);
break;
case 3:
output[op++] = (byte) (value >> 10);
output[op++] = (byte) (value >> 2);
break;
case 4:
this.state = 6;
return false;
case 5:
break;
}
this.state = state;
this.op = op;
return true;
}
}
// --------------------------------------------------------
// encoding
// --------------------------------------------------------
public static String encodeToString(byte[] input, int flags) {
try {
return new String(encode(input, flags), "US-ASCII");
} catch (UnsupportedEncodingException e) {
// US-ASCII is guaranteed to be available.
throw new AssertionError(e);
}
}
public static String encodeToString(byte[] input, int offset, int len, int flags) {
try {
return new String(encode(input, offset, len, flags), "US-ASCII");
} catch (UnsupportedEncodingException e) {
// US-ASCII is guaranteed to be available.
throw new AssertionError(e);
}
}
public static byte[] encode(byte[] input, int flags) {
return encode(input, 0, input.length, flags);
}
public static byte[] encode(byte[] input, int offset, int len, int flags) {
Encoder encoder = new Encoder(flags, null);
// Compute the exact length of the array we will produce.
int output_len = len / 3 * 4;
// Account for the tail of the data and the padding bytes, if any.
if (encoder.do_padding) {
if (len % 3 > 0) {
output_len += 4;
}
} else {
switch (len % 3) {
case 0: break;
case 1: output_len += 2; break;
case 2: output_len += 3; break;
}
}
// Account for the newlines, if any.
if (encoder.do_newline && len > 0) {
output_len += (((len-1) / (3 * Encoder.LINE_GROUPS)) + 1) *
(encoder.do_cr ? 2 : 1);
}
encoder.output = new byte[output_len];
encoder.process(input, offset, len, true);
assert encoder.op == output_len;
return encoder.output;
}
/* package */ static class Encoder extends Coder {
/**
* Emit a new line every this many output tuples. Corresponds to
* a 76-character line length (the maximum allowable according to
* <a href="http://www.ietf.org/rfc/rfc2045.txt">RFC 2045</a>).
*/
public static final int LINE_GROUPS = 19;
/**
* Lookup table for turning Base64 alphabet positions (6 bits)
* into output bytes.
*/
private static final byte ENCODE[] = {
'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',
'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/',
};
/**
* Lookup table for turning Base64 alphabet positions (6 bits)
* into output bytes.
*/
private static final byte ENCODE_WEBSAFE[] = {
'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',
'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '-', '_',
};
final private byte[] tail;
/* package */ int tailLen;
private int count;
final public boolean do_padding;
final public boolean do_newline;
final public boolean do_cr;
final private byte[] alphabet;
public Encoder(int flags, byte[] output) {
this.output = output;
do_padding = (flags & NO_PADDING) == 0;
do_newline = (flags & NO_WRAP) == 0;
do_cr = (flags & CRLF) != 0;
alphabet = ((flags & URL_SAFE) == 0) ? ENCODE : ENCODE_WEBSAFE;
tail = new byte[2];
tailLen = 0;
count = do_newline ? LINE_GROUPS : -1;
}
/**
* @return an overestimate for the number of bytes {@code
* len} bytes could encode to.
*/
public int maxOutputSize(int len) {
return len * 8/5 + 10;
}
public boolean process(byte[] input, int offset, int len, boolean finish) {
// Using local variables makes the encoder about 9% faster.
final byte[] alphabet = this.alphabet;
final byte[] output = this.output;
int op = 0;
int count = this.count;
int p = offset;
len += offset;
int v = -1;
// First we need to concatenate the tail of the previous call
// with any input bytes available now and see if we can empty
// the tail.
switch (tailLen) {
case 0:
// There was no tail.
break;
case 1:
if (p+2 <= len) {
// A 1-byte tail with at least 2 bytes of
// input available now.
v = ((tail[0] & 0xff) << 16) |
((input[p++] & 0xff) << 8) |
(input[p++] & 0xff);
tailLen = 0;
};
break;
case 2:
if (p+1 <= len) {
// A 2-byte tail with at least 1 byte of input.
v = ((tail[0] & 0xff) << 16) |
((tail[1] & 0xff) << 8) |
(input[p++] & 0xff);
tailLen = 0;
}
break;
}
if (v != -1) {
output[op++] = alphabet[(v >> 18) & 0x3f];
output[op++] = alphabet[(v >> 12) & 0x3f];
output[op++] = alphabet[(v >> 6) & 0x3f];
output[op++] = alphabet[v & 0x3f];
if (--count == 0) {
if (do_cr) output[op++] = '\r';
output[op++] = '\n';
count = LINE_GROUPS;
}
}
// At this point either there is no tail, or there are fewer
// than 3 bytes of input available.
// The main loop, turning 3 input bytes into 4 output bytes on
// each iteration.
while (p+3 <= len) {
v = ((input[p] & 0xff) << 16) |
((input[p+1] & 0xff) << 8) |
(input[p+2] & 0xff);
output[op] = alphabet[(v >> 18) & 0x3f];
output[op+1] = alphabet[(v >> 12) & 0x3f];
output[op+2] = alphabet[(v >> 6) & 0x3f];
output[op+3] = alphabet[v & 0x3f];
p += 3;
op += 4;
if (--count == 0) {
if (do_cr) output[op++] = '\r';
output[op++] = '\n';
count = LINE_GROUPS;
}
}
if (finish) {
if (p-tailLen == len-1) {
int t = 0;
v = ((tailLen > 0 ? tail[t++] : input[p++]) & 0xff) << 4;
tailLen -= t;
output[op++] = alphabet[(v >> 6) & 0x3f];
output[op++] = alphabet[v & 0x3f];
if (do_padding) {
output[op++] = '=';
output[op++] = '=';
}
if (do_newline) {
if (do_cr) output[op++] = '\r';
output[op++] = '\n';
}
} else if (p-tailLen == len-2) {
int t = 0;
v = (((tailLen > 1 ? tail[t++] : input[p++]) & 0xff) << 10) |
(((tailLen > 0 ? tail[t++] : input[p++]) & 0xff) << 2);
tailLen -= t;
output[op++] = alphabet[(v >> 12) & 0x3f];
output[op++] = alphabet[(v >> 6) & 0x3f];
output[op++] = alphabet[v & 0x3f];
if (do_padding) {
output[op++] = '=';
}
if (do_newline) {
if (do_cr) output[op++] = '\r';
output[op++] = '\n';
}
} else if (do_newline && op > 0 && count != LINE_GROUPS) {
if (do_cr) output[op++] = '\r';
output[op++] = '\n';
}
assert tailLen == 0;
assert p == len;
} else {
// Save the leftovers in tail to be consumed on the next
// call to encodeInternal.
if (p == len-1) {
tail[tailLen++] = input[p];
} else if (p == len-2) {
tail[tailLen++] = input[p];
tail[tailLen++] = input[p+1];
}
}
this.op = op;
this.count = count;
return true;
}
}
private Base64() { } // don't instantiate
}

- 77,483
- 27
- 203
- 225
In a code compiled with Java 7 but potentially running in a higher java version, it seems useful to detect presence of java.util.Base64
class and use the approach best for given JVM mentioned in other questions here.
I used this code:
private static final Method JAVA_UTIL_BASE64_GETENCODER;
static {
Method getEncoderMethod;
try {
final Class<?> base64Class = Class.forName("java.util.Base64");
getEncoderMethod = base64Class.getMethod("getEncoder");
} catch (ClassNotFoundException | NoSuchMethodException e) {
getEncoderMethod = null;
}
JAVA_UTIL_BASE64_GETENCODER = getEncoderMethod;
}
static String base64EncodeToString(String s) {
final byte[] bytes = s.getBytes(StandardCharsets.ISO_8859_1);
if (JAVA_UTIL_BASE64_GETENCODER == null) {
// Java 7 and older // TODO: remove this branch after switching to Java 8
return DatatypeConverter.printBase64Binary(bytes);
} else {
// Java 8 and newer
try {
final Object encoder = JAVA_UTIL_BASE64_GETENCODER.invoke(null);
final Class<?> encoderClass = encoder.getClass();
final Method encodeMethod = encoderClass.getMethod("encode", byte[].class);
final byte[] encodedBytes = (byte[]) encodeMethod.invoke(encoder, bytes);
return new String(encodedBytes);
} catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) {
throw new IllegalStateException(e);
}
}
}

- 7,670
- 2
- 29
- 44
I know it's way to late to answer, but for JDK 8 and above.
Base64.getEncoder().encodeToString("anyStringData".getBytes());
Base64.getDecoder().decode("encodedData");
imports
import java.util.Base64;

- 661
- 7
- 8
import java.io.UnsupportedEncodingException;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Arrays;
import java.util.Base64;
import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
/***
*
* @author Vaquar khan
*
*
*/
public class AES {
private static SecretKeySpec secretKey;
private static final String VK_secretKey = "VaquarKhan-secrate-key!!!!";
private static byte[] key;
/**
*
* @param myKey
*/
public static void setKey(String myKey) {
MessageDigest sha = null;
try {
key = myKey.getBytes("UTF-8");
sha = MessageDigest.getInstance("SHA-1");
key = sha.digest(key);
key = Arrays.copyOf(key, 16);
secretKey = new SecretKeySpec(key, "AES");
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
}
/**
* encrypt
* @param strToEncrypt
* @param secret
* @return
*/
public static String encrypt(String strToEncrypt, String secret) {
try {
setKey(secret);
Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
cipher.init(Cipher.ENCRYPT_MODE, secretKey);
return Base64.getEncoder().encodeToString(cipher.doFinal(strToEncrypt.getBytes("UTF-8")));
} catch (Exception e) {
System.out.println("Error while encrypting: " + e.toString());
}
return null;
}
/**
* decrypt
* @param strToDecrypt
* @param secret
* @return
*/
public static String decrypt(String strToDecrypt, String secret) {
try {
setKey(secret);
Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5PADDING");
cipher.init(Cipher.DECRYPT_MODE, secretKey);
return new String(cipher.doFinal(Base64.getDecoder().decode(strToDecrypt)));
} catch (Exception e) {
System.out.println("Error while decrypting: " + e.toString());
}
return null;
}
public static void main(String[] args) {
final String secretKey = VK_secretKey;
String password = "VKhan@12";
//
String encryptedString = AES.encrypt(password, secretKey);
String decryptedString = AES.decrypt(encryptedString, secretKey);
//
System.out.println(password);
System.out.println(encryptedString);
System.out.println(decryptedString);
}
}

- 10,864
- 5
- 72
- 96