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程序设计有所帮助。