Android Data encryption Algorithm des,base64 detailed

Source: Internet
Author: User

One, des encryption:

First, the web search for a DES encryption algorithm tool class:

Import java.security.*;
Import javax.crypto.*;

public class Deshelper {

private static String Strdefaultkey = "national";

Private Cipher encryptcipher = null;

Private Cipher decryptcipher = null;

/**
* Convert a byte array to a string representing 16 binary values, such as: byte[]{8,18} to: 0813, and public static byte[]
* Hexstr2bytearr (String strin) mutually reversible conversion process
*
* @param ARRB
* Byte array to convert
* @return The converted String
* @throws Exception
* This method does not handle any exceptions, all exceptions are thrown
*/
public static String Bytearr2hexstr (byte[] arrb) throws Exception {
int ilen = Arrb.length;
Each byte is represented by two characters, so the length of the string is twice times the length of the array
StringBuffer sb = new StringBuffer (Ilen * 2);
for (int i = 0; i < Ilen; i++) {
int inttmp = Arrb[i];
Convert negative numbers to positive numbers
while (Inttmp < 0) {
inttmp = inttmp + 256;
}
Numbers less than 0F need to be preceded by 0
if (Inttmp < 16) {
Sb.append ("0");
}
Sb.append (Integer.tostring (inttmp, 16));
}
return sb.tostring ();
}

/**
* Converts a String representing 16 binary values to a byte array, and public static string Bytearr2hexstr (byte[] arrb)
* Reciprocal Reversible conversion process
*
* @param strin
* Strings that need to be converted
* @return converted byte array
* @throws Exception
* This method does not handle any exceptions, all exceptions are thrown
* @author <a href= "Mailto:[email protected]" >LiGuoQing</a>
*/
public static byte[] Hexstr2bytearr (String strin) throws Exception {
byte[] Arrb = Strin.getbytes ();
int ilen = Arrb.length;

Two characters represent one byte, so the length of the byte array is the length of the string divided by 2
byte[] Arrout = new BYTE[ILEN/2];
for (int i = 0; i < ilen; i = i + 2) {
String strtmp = new String (ARRB, I, 2);
ARROUT[I/2] = (byte) integer.parseint (strtmp, 16);
}
return arrout;
}

/**
* Default constructor method, use default key
*
* @throws Exception
*/
Public Deshelper () throws Exception {
This (Strdefaultkey);
}

/**
* Specify key construction methods
*
* @param strkey
* The specified key
* @throws Exception
*/
Public Deshelper (String strkey) throws Exception {
Security.addprovider (New Com.sun.crypto.provider.SunJCE ());
Key key = GetKey (Strkey.getbytes ());

Encryptcipher = Cipher.getinstance ("DES");
Encryptcipher.init (Cipher.encrypt_mode, key);

Decryptcipher = Cipher.getinstance ("DES");
Decryptcipher.init (Cipher.decrypt_mode, key);
}

/**
* Encrypt byte array
*
* @param ARRB
* Byte array to be encrypted
* @return the encrypted byte array
* @throws Exception
*/
Public byte[] Encrypt (byte[] arrb) throws Exception {
Return encryptcipher.dofinal (ARRB);
}

/**
* Encrypt string
*
* @param strin
* Strings to be encrypted
* @return The encrypted string
* @throws Exception
*/
public string Encrypt (string strin) throws Exception {
Return Bytearr2hexstr (Encrypt (Strin.getbytes ()));
}

/**
* Decrypt byte array
*
* @param ARRB
* Byte array to decrypt
* @return the decrypted byte array
* @throws Exception
*/
Public byte[] Decrypt (byte[] arrb) throws Exception {
Return decryptcipher.dofinal (ARRB);
}

/**
* Decrypt string
*
* @param strin
* The string to be decrypted
* @return The decrypted string
* @throws Exception
*/
public string Decrypt (string Strin) throws Exception {
return new String (Decrypt (Hexstr2bytearr (Strin)));
}

/**
* Generate a key from the specified string, the required byte array length for the key is 8 bits less than 8 bits when the back 0, more than 8 bits only take the first 8 bits
*
* @param arrbtmp
* The byte array that makes up the string
* @return The generated key
* @throws java.lang.Exception
*/
Private Key GetKey (byte[] arrbtmp) throws Exception {
Create an empty 8-byte array (default is 0)
byte[] ARRB = new Byte[8];

Converts the original byte array to 8 bits
for (int i = 0; i < arrbtmp.length && i < arrb.length; i++) {
Arrb[i] = Arrbtmp[i];
}

Generate key
Key key = new Javax.crypto.spec.SecretKeySpec (ARRB, "DES");

Return key;
}
}

How to use the DES encryption algorithm:

Here's what I do when I'm developing Android, which involves encrypting the data to the server-side, including the image attachment, to the part of the code.

File File = new file (path);
FileInputStream Stream;
try {
stream = new FileInputStream (file);
int filesize = stream.available ();
SYSTEM.OUT.PRINTLN ("Attachment size:" +filesize);
if (filesize>maxfile) {
Attachment.seterror ("Attachments cannot be greater than 2m!");
Return
}
byte[] bytes = new Byte[filesize];
Stream.read (bytes);//The file must be converted to a byte array before transmitting the attachment.
Deshelper des;
try {
des = new Deshelper ("test");//Custom key
Byte[] encodebytes =des.encrypt (bytes);//When encrypting with the DES algorithm, first encrypt the byte array and then turn to the Bytearr2hexstr method of the DES encryption algorithm to convert the byte array to a string of 16 binary values. The string conversion method of the new string (encodebytes) cannot be used here directly.
String image = Des.bytearr2hexstr (encodebytes);
Jsonobject json = new Jsonobject ();
Json.put ("name", "Henry");
Json.put ("Selectedtypeid", Selectedtypeid);
Json.put ("BeginTime", beginTime);
Json.put ("Reason", reason);
Json.put ("image", image);
String str = json.tostring ();//Convert to JSON string for easy encrypted transmission
SYSTEM.OUT.PRINTLN ("Size of the string to be encrypted:" +str.getbytes (). length);
SimpleDateFormat format1=new SimpleDateFormat ("Yyyy-mm-dd HH:mm:ss:SSS");
System.out.println ("String before Encryption:" +STR);
System.out.println ("Start encryption Time:" +format1.format (new Date ()));
String encodestr =des.encrypt (str);
SYSTEM.OUT.PRINTLN ("End Encryption Time:" +format1.format (New Date ()));
System.out.println ("Encrypted string:" +encodestr);

System.out.println ("string size after Encryption:" +encodestr.getbytes (). length);

/************************************** decryption Process **********************************************/



System.out.println ("Start decryption Time:" +format1.format (New Date ()));
String Decodestr=des.decrypt (ENCODESTR);
System.out.println ("End decryption Time:" +format1.format (New Date ()));
System.out.println ("Decrypted string:" +decodestr);
Jsonobject object = new Jsonobject (DECODESTR);
string img = (string) object.get ("image");
Byte[] getbyte =des.hexstr2bytearr (IMG);

You cannot use the Img.getbytes () method here to get the byte array as a parameter of the decrypt method, you must first convert the string img of the 16 binary value to a byte array, calling the Hexstr2bytearr method
Byte[] images= des.decrypt (getbyte);
System.out.println ("Length:" +images.length);

Read the decrypted picture file
Bitmap Bitmap =bitmapfactory.decodebytearray (images, 0, images.length);

。。。。。。

} catch (Exception E1) {
E1.printstacktrace ();
}
}catch (FileNotFoundException E1) {
E1.printstacktrace ();
} catch (IOException e) {
E.printstacktrace ();
} catch (Org.apache.http.ParseException e) {
E.printstacktrace ();
}

If you use BASE64 encryption, it is relatively simple:

Call Android's own tool class Android.util.Base64

To encrypt a byte array

byte[] encode = Base64.encode (bytes, base64.default);

Convert to string for transfer

String image= new string (encode);

To decrypt a string and convert it into a byte array

byte[] Images =base64.decode (image.getbytes (), base64.default);

Contact Us

The content source of this page is from Internet, which doesn't represent Alibaba Cloud's opinion; products and services mentioned on that page don't have any relationship with Alibaba Cloud. If the content of the page makes you feel confusing, please write us an email, we will handle the problem within 5 days after receiving your email.

If you find any instances of plagiarism from the community, please send an email to: info-contact@alibabacloud.com and provide relevant evidence. A staff member will contact you within 5 working days.

A Free Trial That Lets You Build Big!

Start building with 50+ products and up to 12 months usage for Elastic Compute Service

  • Sales Support

    1 on 1 presale consultation

  • After-Sales Support

    24/7 Technical Support 6 Free Tickets per Quarter Faster Response

  • Alibaba Cloud offers highly flexible support services tailored to meet your exact needs.