Android编程加密算法小结(AES、Base64、RAS加密算法)

本文实例总结了Android编程加密算法。分享给大家供大家参考，具体如下：

android常用加密算法之Base64加密算法：

package com.long;
/**
 * 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.ByteArrayOutputStream;
import java.io.IOException;
import java.io.OutputStream;
/*
 * @author long
 *
 */
public class Base64 {
 private static final char[] legalChars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
   .toCharArray();
 public static String encode(byte[] data) {
  int start = 0;
  int len = data.length;
  StringBuffer buf = new StringBuffer(data.length * 3 / 2);
  int end = len - 3;
  int i = start;
  int n = 0;
  while (i <= end) {
   int d = ((((int) data[i]) & 0x0ff) << 16)
     | ((((int) data[i + 1]) & 0x0ff) << 8)
     | (((int) data[i + 2]) & 0x0ff);
   buf.append(legalChars[(d >> 18) & 63]);
   buf.append(legalChars[(d >> 12) & 63]);
   buf.append(legalChars[(d >> 6) & 63]);
   buf.append(legalChars[d & 63]);
   i += 3;
   if (n++ >= 14) {
    n = 0;
    buf.append(" ");
   }
  }
  if (i == start + len - 2) {
   int d = ((((int) data[i]) & 0x0ff) << 16)
     | ((((int) data[i + 1]) & 255) << 8);
   buf.append(legalChars[(d >> 18) & 63]);
   buf.append(legalChars[(d >> 12) & 63]);
   buf.append(legalChars[(d >> 6) & 63]);
   buf.append("=");
  } else if (i == start + len - 1) {
   int d = (((int) data[i]) & 0x0ff) << 16;
   buf.append(legalChars[(d >> 18) & 63]);
   buf.append(legalChars[(d >> 12) & 63]);
   buf.append("==");
  }
  return buf.toString();
 }
 private static int decode(char c) {
  if (c >= 'A' && c <= 'Z')
   return ((int) c) - 65;
  else if (c >= 'a' && c <= 'z')
   return ((int) c) - 97 + 26;
  else if (c >= '0' && c <= '9')
   return ((int) c) - 48 + 26 + 26;
  else
   switch (c) {
   case '+':
    return 62;
   case '/':
    return 63;
   case '=':
    return 0;
   default:
    throw new RuntimeException("unexpected code: " + c);
   }
 }
 public static byte[] decode(String s) {
  ByteArrayOutputStream bos = new ByteArrayOutputStream();
  try {
   decode(s, bos);
  } catch (IOException e) {
   throw new RuntimeException();
  }
  byte[] decodedBytes = bos.toByteArray();
  try {
   bos.close();
   bos = null;
  } catch (IOException ex) {
   System.err.println("Error while decoding BASE64: " + ex.toString());
  }
  return decodedBytes;
 }
 private static void decode(String s, OutputStream os) throws IOException {
  int i = 0;
  int len = s.length();
  while (true) {
   while (i < len && s.charAt(i) <= ' ')
    i++;
   if (i == len)
    break;
   int tri = (decode(s.charAt(i)) << 18)
     + (decode(s.charAt(i + 1)) << 12)
     + (decode(s.charAt(i + 2)) << 6)
     + (decode(s.charAt(i + 3)));
   os.write((tri >> 16) & 255);
   if (s.charAt(i + 2) == '=')
    break;
   os.write((tri >> 8) & 255);
   if (s.charAt(i + 3) == '=')
    break;
   os.write(tri & 255);
   i += 4;
  }
 }
}

android常用加密算法之AES加密算法：

package com.long;
import java.security.SecureRandom;
import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
/**
 * AES加密解密算法
 * 
 * @author long
 * 
 */
public class Encryption {
 private final static String HEX = "0123456789ABCDEF";
 public static String encrypt(String seed, String cleartext)
   throws Exception {
  byte[] rawKey = getRawKey(seed.getBytes());
  byte[] result = encrypt(rawKey, cleartext.getBytes());
  return toHex(result);
 }
 public static String decrypt(String seed, String encrypted)
   throws Exception {
  byte[] rawKey = getRawKey(seed.getBytes());
  byte[] enc = toByte(encrypted);
  byte[] result = decrypt(rawKey, enc);
  return new String(result);
 }
 private static byte[] getRawKey(byte[] seed) throws Exception {
  KeyGenerator kgen = KeyGenerator.getInstance("AES");
  SecureRandom sr = SecureRandom.getInstance("SHA1PRNG");
  sr.setSeed(seed);
  kgen.init(128, sr); // 192 and 256 bits may not be available
  SecretKey skey = kgen.generateKey();
  byte[] raw = skey.getEncoded();
  return raw;
 }
 private static byte[] encrypt(byte[] raw, byte[] clear) throws Exception {
  SecretKeySpec skeySpec = new SecretKeySpec(raw, "AES");
  Cipher cipher = Cipher.getInstance("AES");
  cipher.init(Cipher.ENCRYPT_MODE, skeySpec);
  byte[] encrypted = cipher.doFinal(clear);
  return encrypted;
 }
 private static byte[] decrypt(byte[] raw, byte[] encrypted)
   throws Exception {
  SecretKeySpec skeySpec = new SecretKeySpec(raw, "AES");
  Cipher cipher = Cipher.getInstance("AES");
  cipher.init(Cipher.DECRYPT_MODE, skeySpec);
  byte[] decrypted = cipher.doFinal(encrypted);
  return decrypted;
 }
 public static String toHex(String txt) {
  return toHex(txt.getBytes());
 }
 public static String fromHex(String hex) {
  return new String(toByte(hex));
 }
 public static byte[] toByte(String hexString) {
  int len = hexString.length() / 2;
  byte[] result = new byte[len];
  for (int i = 0; i < len; i++)
   result[i] = Integer.valueOf(hexString.substring(2 * i, 2 * i + 2),
     16).byteValue();
  return result;
 }
 public static String toHex(byte[] buf) {
  if (buf == null)
   return "";
  StringBuffer result = new StringBuffer(2 * buf.length);
  for (int i = 0; i < buf.length; i++) {
   appendHex(result, buf[i]);
  }
  return result.toString();
 }
 private static void appendHex(StringBuffer sb, byte b) {
  sb.append(HEX.charAt((b >> 4) & 0x0f)).append(HEX.charAt(b & 0x0f));
 }
}

Android常用加密算法之RAS加密算法：

import java.security.Key; 
import java.security.KeyFactory; 
import java.security.KeyPair; 
import java.security.KeyPairGenerator; 
import java.security.PrivateKey; 
import java.security.PublicKey; 
import java.security.interfaces.RSAPrivateKey; 
import java.security.interfaces.RSAPublicKey; 
import java.security.spec.PKCS8EncodedKeySpec; 
import java.security.spec.X509EncodedKeySpec; 
import javax.crypto.Cipher; 
import sun.misc.BASE64Decoder; 
import sun.misc.BASE64Encoder; 
public class RSAHelper { 
  public static PublicKey getPublicKey(String key) throws Exception { 
   byte[] keyBytes; 
   keyBytes = (new BASE64Decoder()).decodeBuffer(key); 
   X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes); 
   KeyFactory keyFactory = KeyFactory.getInstance("RSA"); 
   PublicKey publicKey = keyFactory.generatePublic(keySpec); 
   return publicKey; 
  } 
  public static PrivateKey getPrivateKey(String key) throws Exception { 
   byte[] keyBytes; 
   keyBytes = (new BASE64Decoder()).decodeBuffer(key); 
   PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(keyBytes); 
   KeyFactory keyFactory = KeyFactory.getInstance("RSA"); 
   PrivateKey privateKey = keyFactory.generatePrivate(keySpec); 
   return privateKey; 
  } 
  public static String getKeyString(Key key) throws Exception { 
   byte[] keyBytes = key.getEncoded(); 
   String s = (new BASE64Encoder()).encode(keyBytes); 
   return s; 
  } 
  public static void main(String[] args) throws Exception { 
   KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA"); 
   //密钥位数 
   keyPairGen.initialize(1024); 
   //密钥对 
   KeyPair keyPair = keyPairGen.generateKeyPair(); 
   // 公钥 
   PublicKey publicKey = (RSAPublicKey) keyPair.getPublic(); 
   // 私钥 
   PrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate(); 
   String publicKeyString = getKeyString(publicKey); 
   System.out.println("public:\n" + publicKeyString); 
   String privateKeyString = getKeyString(privateKey); 
   System.out.println("private:\n" + privateKeyString); 
   //加解密类 
   Cipher cipher = Cipher.getInstance("RSA");//Cipher.getInstance("RSA/ECB/PKCS1Padding"); 
   //明文 
   byte[] plainText = "我们都很好！邮件：@sina.com".getBytes(); 
   //加密 
   cipher.init(Cipher.ENCRYPT_MODE, publicKey); 
   byte[] enBytes = cipher.doFinal(plainText); 
   //通过密钥字符串得到密钥 
   publicKey = getPublicKey(publicKeyString); 
   privateKey = getPrivateKey(privateKeyString); 
   //解密 
   cipher.init(Cipher.DECRYPT_MODE, privateKey); 
   byte[]deBytes = cipher.doFinal(enBytes); 
   publicKeyString = getKeyString(publicKey); 
   System.out.println("public:\n" +publicKeyString); 
   privateKeyString = getKeyString(privateKey); 
   System.out.println("private:\n" + privateKeyString); 
   String s = new String(deBytes); 
   System.out.println(s); 
  } 
}

希望本文所述对大家Android程序设计有所帮助。