DES定義（百度百科）

DES對稱加密，對稱加密，是一種比較傳統(tǒng)的加密方式，其加密運算、解密運算使用的是同樣的密鑰，信息的發(fā)送者和信息的接收者在進行信息的傳輸與處理時，必須共同持有該密碼（稱為對稱密碼），是一種對稱加密算法。DES 使用一個 56 位的密鑰以及附加的 8 位奇偶校驗位，產生最大 64 位的分組大小。這是一個迭代的分組密碼，使用稱為 Feistel 的技術，其中將加密的文本塊分成兩半。使用子密鑰對其中一半應用循環(huán)功能，然后將輸出與另一半進行“異或”運算；接著交換這兩半，這一過程會繼續(xù)下去，但最后一個循環(huán)不交換。DES 使用 16 個循環(huán)，使用異或，置換，代換，移位操作四種基本運算。

DES加密需要注意：加密模式、加密填充方式、偏移量。

加密模式： ECB、CBC、CTR、OFB、CFB。
加密填充方式：pacs7padding、pacs5padding、zeropadding、iso10126、ansix923。
偏移量：ECB沒有偏移量，對秘鑰沒有位數限制。CBC以及其他模式是需要偏移量和秘鑰是8位的，在有的很多語言中封裝的并沒有對偏移量與秘鑰進行位數超過8位進行限定，內部其實對偏移量和秘鑰進行了截取前8位的操作的。

DES的作用：

1、移動端對數據進行DES加密之后，向服務器傳輸明文數據和已加密數據，這樣防止通過鏈接惡意攻擊服務器，
2、對密碼進行加密，傳輸到服務器端，再進行解密，這樣不裸露傳輸，有效的保護密碼。

android端使用

DES加密需要服務器端和移動端共同持有相同的秘鑰和偏移量，為了安全，秘鑰和偏移量就得重點保護，android端中對秘鑰和偏移量的有效保護就只能選擇使用NDK在c/c++中進行調用了。

java與C++ 代碼：

  /**
     * 加密
     * @param source 明文
     * @return 密文
     */
public class DESUtils {
  static {
        System.loadLibrary("native-demo-lib");
    }
 /**
     * 加密
     * @param source 明文
     * @return 密文
     */
    public native static byte[] encryptNative(byte[] source);

    /**
     * 解密
     * @param source 密文
     * @return 明文
     */
    public native static byte[] decryptNative(byte[] source);
 /**
     * 封裝秘鑰
     *
     * @return 秘鑰對象
     * @throws Exception 異常
     */
    private static Key toKey(byte[] key,String desType) throws Exception {
        DESKeySpec dks = new DESKeySpec(key);
        SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(desType);
        return  keyFactory.generateSecret(dks);
    }

    /**
     * DES解密，NDK中調用,方法名與參數列表不得更改
     *
     * @param data 密文
     * @return 明文
     * @throws Exception 異常
     */
    public static byte[] decrypt(byte[] data, byte[] key, byte[] py,String desType,String desMode) throws Exception {
        Key k = toKey(key,desType);
        Cipher cipher = Cipher.getInstance(desMode);
        IvParameterSpec iv = new IvParameterSpec(py);
        cipher.init(Cipher.DECRYPT_MODE, k, iv);//解密模式

        return cipher.doFinal(data);
    }

    /**
     * DES加密，NDK中調用,方法名與參數列表不得更改
     *
     * @param data 明文
     * @return 密文
     * @throws Exception 異常
     */
    public static byte[] encrypt(byte[] data, byte[] key, byte[] py,String desType,String desMode) throws Exception {
        Key k = toKey(key,desType);
        Cipher cipher = Cipher.getInstance(desMode);
        IvParameterSpec iv = new IvParameterSpec(py);
        cipher.init(Cipher.ENCRYPT_MODE, k, iv);//加密模式
        return cipher.doFinal(data);
    }

    /**
     * 加密字符串
     *
     * @param data 被加密字符串
     * @return 返回加密字符串
     */
    public static String encryptString(String data) {
        try {
            return encryptBASE64(encryptNative(data.getBytes("UTF-8")));
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        return "";
    }

    /**
     * 解密字符串
     * @param source 密文
     * @return 明文
     */
    public static String decryptString(String source){
        try{
            return new String(decryptNative(decryptBASE64(source)),"UTF-8");
        }catch (Exception ex){
            ex.printStackTrace();
        }
        return "";
    }
}

//秘鑰（自定義）
#define KEY "12345678"
//偏移量(自定義)
#define PY "qwertyui"
//加密方式
const char *DES_TYPE = "DES";
//DES加密填充方式（也可以選擇PKCS5Padding）
const char *DES_MODE = "DES/CBC/PKCS7Padding";
jbyteArray getBytes(JNIEnv *env, const char *source);

jbyteArray getArray(JNIEnv *env,  _jclass *type, const _jbyteArray *source_, const char*name,const char*sig);

extern "C" {
/**
 * DES加密
 * @param env
 * @param type
 * @param source_ 明文
 * @return 密文
 */
JNIEXPORT jbyteArray JNICALL
Java_com_wanhe_eng100_listening_utils_DESUtils_encryptNative(JNIEnv *env, jclass type,
                                                             jbyteArray source_) {
    const char* name = "encrypt";
    const char* sig = "([B[B[BLjava/lang/String;Ljava/lang/String;)[B";
    jbyteArray result = getArray(env, type, source_,name,sig);
    name = NULL;
    sig = NULL;
    return result;
}

/**
 * DES解密
 * @param env
 * @param type
 * @param source_ 密文
 * @return 明文
 */
JNIEXPORT jbyteArray JNICALL
Java_com_wanhe_eng100_listening_utils_DESUtils_decryptNative(JNIEnv *env, jclass type,
                                                             jbyteArray source_) {
    const char* name = "decrypt";
    const char* sig = "([B[B[BLjava/lang/String;Ljava/lang/String;)[B";

    jbyteArray result = getArray(env, type, source_,name,sig);

    name = NULL;
    sig = NULL;
    return result;
    }
}
/**
 * 返回加密或者解密之后的jbyteArray
 * @param env 
 * @param type 
 * @param source_ 
 * @param name 
 * @param sig 
 * @return 
 */
jbyteArray getArray(JNIEnv *env,  _jclass *type, const _jbyteArray *source_, const char* name, const char* sig) {
    jstring desType_, desMode_;
    jbyteArray keyArray, pyArray;
    jmethodID encryptMid;

    desType_ = env->NewStringUTF(DES_TYPE);
    desMode_ = env->NewStringUTF(DES_MODE);
    //將key轉轉成jbyteArray
    keyArray = getBytes(env, KEY);
    //將偏移量轉成jbyteArray
    pyArray = getBytes(env, PY);

    encryptMid = env->GetStaticMethodID(type, name,
                                        sig);
    //調用DESUtils類中的加密方法
    jbyteArray result = (jbyteArray) env->CallStaticObjectMethod(type, encryptMid, source_,
                                                                 keyArray, pyArray, desType_,
                                                                 desMode_);
    //釋放
    env->DeleteLocalRef(desType_);
    env->DeleteLocalRef(desMode_);
    env->DeleteLocalRef(keyArray);
    env->DeleteLocalRef(pyArray);
    return result;
}
/**
 * 將字符串轉換jbyteArray
 * @param env
 * @param source
 * @return
 */
jbyteArray getBytes(JNIEnv *env, const char *source) {
    jstring str = env->NewStringUTF(source);
    jstring utf8 = env->NewStringUTF("UTF-8");
    jclass stringClazz = env->FindClass("java/lang/String");//尋找 java里面String.class
    jmethodID stringMid = env->GetMethodID(stringClazz, "getBytes", "(Ljava/lang/String;)[B");
    return (jbyteArray) env->CallObjectMethod(str, stringMid, utf8);
}

本文章著作版權所屬：微笑面對,請關注我的CSDN博客：這里寫鏈接內容