锐客网

  1. 首页 > 睿知 > it技术 > >

Android系统自带的android.util.Base64的实现源码

IT知识androidAndroid系统

书到用时方恨少，事非经过不知难。这篇文章主要讲述Android系统自带的android.util.Base64的实现源码相关的知识，希望能为你提供帮助。
【Android系统自带的android.util.Base64的实现源码】  由于android逆向还原的时候，经常需要用到android.util.Base64的代码，因此从Android 4.4.4的 系统里抠出来进行备份，懒得用其他的代码进行修改替换了。

/*
* Copyright (C) 2010 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/


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
/**
* Default values for encoder/decoder flags.
*/
public static final int DEFAULT = 0;

/**
* Encoder flag bit to omit the padding = characters at the end
* of the output (if any).
*/
public static final int NO_PADDING = 1;

/**
* Encoder flag bit to omit all line terminators (i.e., the output
* will be on one long line).
*/
public static final int NO_WRAP = 2;

/**
* Encoder flag bit to indicate lines should be terminated with a
* CRLF pair instead of just an LF.Has no effect if @code
* NO_WRAP is specified as well.
*/
public static final int CRLF = 4;

/**
* Encoder/decoder flag bit to indicate using the "URL and
* filename safe" variant of Base64 (see RFC 3548 section 4) where
* @code - and @code _ are used in place of @code + and
* @code /.
*/
public static final int URL_SAFE = 8;

/**
* Flag to pass to @linkto indicate that it
* should not close the output stream it is wrapping when it
* itself is closed.
*/
public static final int NO_CLOSE = 16;

//--------------------------------------------------------
//shared code
//--------------------------------------------------------

/* package */ static abstract class Coder
public byte[] output;
public int op;

/**
* Encode/decode another block of input data.this.output is
* provided by the caller, and must be big enough to hold all
* the coded data.On exit, this.opwill be set to the length
* of the coded data.
*
* @param finish true if this is the final call to process for
*this object.Will finalize the coder state and
*include any final bytes in the output.
*
* @return true if the input so far is good; false if some
*error has been detected in the input stream..
*/
public abstract boolean process(byte[] input, int offset, int len, boolean finish);

/**
* @return the maximum number of bytes a call to process()
* could produce for the given number of input bytes.This may
* be an overestimate.
*/
public abstract int maxOutputSize(int len);


//--------------------------------------------------------
//decoding
//--------------------------------------------------------

/**
* Decode the Base64-encoded data in input and return the data in
* a new byte array.
*
* < p> The padding = characters at the end are considered optional, but
* if any are present, there must be the correct number of them.
*
* @param strthe input String to decode, which is converted to
*bytes using the default charset
* @param flagscontrols certain features of the decoded output.
*Pass @code DEFAULT to decode standard Base64.
*
* @throws IllegalArgumentException if the input contains
* incorrect padding
*/
public static byte[] decode(String str, int flags)
return decode(str.getBytes(), flags);


/**
* Decode the Base64-encoded data in input and return the data in
* a new byte array.
*
* < p> The padding = characters at the end are considered optional, but
* if any are present, there must be the correct number of them.
*
* @param input the input array to decode
* @param flagscontrols certain features of the decoded output.
*Pass @code DEFAULT to decode standard Base64.
*
* @throws IllegalArgumentException if the input contains
* incorrect padding
*/
public static byte[] decode(byte[] input, int flags)
return decode(input, 0, input.length, flags);


/**
* Decode the Base64-encoded data in input and return the data in
* a new byte array.
*
* < p> The padding = characters at the end are considered optional, but
* if any are present, there must be the correct number of them.
*
* @param inputthe data to decode
* @param offset the position within the input array at which to start
* @param lenthe number of bytes of input to decode
* @param flagscontrols certain features of the decoded output.
*Pass @code DEFAULT to decode standard Base64.
*
* @throws IllegalArgumentException if the input contains
* incorrect padding
*/
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;


/* package */ static class Decoder extends Coder
/**
* Lookup table for turning bytes into their position in the
* Base64 alphabet.
*/
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;

/**
* States 0-3 are reading through the next input tuple.
* State 4 is having read one = and expecting exactly
* one more.
* State 5 is expecting no more data or padding characters
* in the input.
* State 6 is the error state; an error has been detected
* in the input and no future input can "fix" it.
*/
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 = https://www.songbingjia.com/android/0;


/**
* @return an overestimate for the number of bytes @code
* len bytes could decode to.
*/
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;

// Using local variables makes the decoder about 12%
// faster than if we manipulate the member variables in
// the loop.(Even alphabet makes a measurable
// difference, which is somewhat surprising to me since
// the member variable is final.)
int state = this.state;
int value = https://www.songbingjia.com/android/this.value;
int op = 0;
final byte[] output = this.output;
final int[] alphabet = this.alphabet;

while (p < len)
// Try the fast path:were starting a new tuple and the
// next four bytes of the input stream are all data
// bytes.This corresponds to going through states
// 0-1-2-3-0.We expect to use this method for most of
// the data.
//
// If any of the next four bytes of input are non-data
// (whitespace, etc.), value will end up negative.(All
// the non-data values in decode are small negative
// numbers, so shifting any of them up and oring them
// together will result in a value with its top bit set.)
//
// You can remove this whole block and the output should
// be the same, just slower.
if (state == 0)
while (p+4 < = len & &
(value = https://www.songbingjia.com/android/((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;


// The fast path isnt available -- either weve read a
// partial tuple, or the next four input bytes arent all
// data, or whatever.Fall back to the slower state
// machine implementation.

int d = alphabet[input[p++] & 0xff];


    推荐阅读


    上一篇：驱动实现强制重启与关机操作

    下一篇：Python中hashlib模块的使用