자바 의 각종 암호 화 알고리즘

 JAVA 에서 저 희 를 위해 풍부 한 암호 화 기술 을 제 공 했 습 니 다. 기본적으로 단 방향 암호 화 와 비대 칭 암호 화로 나 눌 수 있 습 니 다.
 1. 단 방향 암호 화 알고리즘
 단 방향 암호 화 알고리즘 은 주로 데이터 전송 과정 에서 변경 되 었 는 지 검증 하 는 데 사용 된다.
BASE 64 는 암호 화 알고리즘 이 아 닌 인 코딩 형식 에 속한다.
MD5 (메시지 다이제스트 알고리즘 5, 정보 요약 알고리즘) SHA (Secure Hash Algorithm, 보안 해시 알고리즘) HMAC (Hash 메시지 인증 코드, 해시 메시지 감별 코드  2. 대칭 과 비대 칭 암호 화 알고리즘
   대칭 과 비대 칭 암호 화 알고리즘 은 주로 공개 키 와 비밀 키 의 형식 으로 데 이 터 를 암호 화 합 니 다.
DES (Data Encryption Standard, 데이터 암호 화 알고리즘) PBE (암호 기반 암호 화, 암호 인증 기반) RSA (알고리즘 이름 은 발명자 의 이름 으로 Ron Rivest, AdiShamir 와 Leonard Adleman) DH (Diffie - Hellman 알고리즘, 키 일치 프로 토 콜) DSA (디지털 서명 알고리즘, 디지털 서명) ECC (Elliptic Curves Cryptography, 타원 곡선 암호 코딩 학)
  더 많은 이론 적 인 소 개 는 스스로 찾 아 보고 아래 에 코드 를 제공 하여 보 세 요.
  기초 암호 화
 

package com.test;
import java.security.MessageDigest;

import javax.crypto.KeyGenerator;
import javax.crypto.Mac;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;

import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;

/**  
 * @ClassName: coder   
 * @Description:     
 * @author: LUCKY  
 * @date:2016 1 4    1:24:12     
 */ 
public abstract class coder {
    public static final String KEY_SHA = "SHA";
    public static final String KEY_MD5 = "MD5";
 
    /**
     * MAC          
     * 
     * 

     * HmacMD5 
     * HmacSHA1 
     * HmacSHA256 
     * HmacSHA384 
     * HmacSHA512
     * 
*/
public static final String KEY_MAC = "HmacMD5";
/**
* BASE 64 복호화
* 
* @param key
* @return
* @throws Exception
*/
public static byte[] decryptBASE64(String key) throws Exception {
return (new BASE64Decoder()).decodeBuffer(key);
}
/**
* BASE 64 암호 화
* 
* @param key
* @return
* @throws Exception
*/
public static String encryptBASE64(byte[] key) throws Exception {
return (new BASE64Encoder()).encodeBuffer(key);
}
/**
* MD5 암호 화
* 
* @param data
* @return
* @throws Exception
*/
public static byte[] encryptMD5(byte[] data) throws Exception {
MessageDigest md5 = MessageDigest.getInstance(KEY_MD5);
md5.update(data);
return md5.digest();
}
/**
* SHA 암호 화
* 
* @param data
* @return
* @throws Exception
*/
public static byte[] encryptSHA(byte[] data) throws Exception {
MessageDigest sha = MessageDigest.getInstance(KEY_SHA);
sha.update(data);
return sha.digest();
}
/**
* HMAC 키 초기 화
* 
* @return
* @throws Exception
*/
public static String initMacKey() throws Exception {
KeyGenerator keyGenerator = KeyGenerator.getInstance(KEY_MAC);
SecretKey secretKey = keyGenerator.generateKey();
return encryptBASE64(secretKey.getEncoded());
}
/**
* HMAC 암호 화
* 
* @param data
* @param key
* @return
* @throws Exception
*/
public static byte[] encryptHMAC(byte[] data, String key) throws Exception {
SecretKey secretKey = new SecretKeySpec(decryptBASE64(key), KEY_MAC);
Mac mac = Mac.getInstance(secretKey.getAlgorithm());
mac.init(secretKey);
return mac.doFinal(data);
}
} 
RSA 보안 인 코딩 구성 요소
  
package com.test;
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.Signature;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.HashMap;
import java.util.Map;

import javax.crypto.Cipher;
 

/**  
 * @ClassName: RSACoder   
 * @Description: RSA      
 * @author: LUCKY  
 * @date:2016 1 4    1:25:34     
 */ 
public abstract class RSACoder extends coder {
    public static final String KEY_ALGORITHM = "RSA";
    public static final String SIGNATURE_ALGORITHM = "MD5withRSA";
 
    private static final String PUBLIC_KEY = "RSAPublicKey";
    private static final String PRIVATE_KEY = "RSAPrivateKey";
 
    /**
     *             
     * 
     * @param data
     *                
     * @param privateKey
     *              
     * 
     * @return
     * @throws Exception
     */
    public static String sign(byte[] data, String privateKey) throws Exception {
        //    base64     
        byte[] keyBytes = decryptBASE64(privateKey);
 
        //   PKCS8EncodedKeySpec  
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
 
        // KEY_ALGORITHM        
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
 
        //       
        PrivateKey priKey = keyFactory.generatePrivate(pkcs8KeySpec);
 
        //             
        Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
        signature.initSign(priKey);
        signature.update(data);
 
        return encryptBASE64(signature.sign());
    }
 
    /**
     *       
     * 
     * @param data
     *                
     * @param publicKey
     *              
     * @param sign
     *                
     * 
     * @return       true     false
     * @throws Exception
     * 
     */
    public static boolean verify(byte[] data, String publicKey, String sign)
            throws Exception {
 
        //    base64     
        byte[] keyBytes = decryptBASE64(publicKey);
 
        //   X509EncodedKeySpec  
        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
 
        // KEY_ALGORITHM        
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
 
        //       
        PublicKey pubKey = keyFactory.generatePublic(keySpec);
 
        Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
        signature.initVerify(pubKey);
        signature.update(data);
 
        //         
        return signature.verify(decryptBASE64(sign));
    }
 
    /**
     *   

     *      
     * 
     * @param data
     * @param key
     * @return
     * @throws Exception
     */
    public static byte[] decryptByPrivateKey(byte[] data, String key)
            throws Exception {
        //      
        byte[] keyBytes = decryptBASE64(key);
 
        //     
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        Key privateKey = keyFactory.generatePrivate(pkcs8KeySpec);
 
        //      
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.DECRYPT_MODE, privateKey);
 
        return cipher.doFinal(data);
    }
 
    /**
     *   

     *      
     * 
     * @param data
     * @param key
     * @return
     * @throws Exception
     */
    public static byte[] decryptByPublicKey(byte[] data, String key)
            throws Exception {
        //      
        byte[] keyBytes = decryptBASE64(key);
 
        //     
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        Key publicKey = keyFactory.generatePublic(x509KeySpec);
 
        //      
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.DECRYPT_MODE, publicKey);
 
        return cipher.doFinal(data);
    }
 
    /**
     *   

     *      
     * 
     * @param data
     * @param key
     * @return
     * @throws Exception
     */
    public static byte[] encryptByPublicKey(byte[] data, String key)
            throws Exception {
        //      
        byte[] keyBytes = decryptBASE64(key);
 
        //     
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        Key publicKey = keyFactory.generatePublic(x509KeySpec);
 
        //      
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.ENCRYPT_MODE, publicKey);
 
        return cipher.doFinal(data);
    }
 
    /**
     *   

     *      
     * 
     * @param data
     * @param key
     * @return
     * @throws Exception
     */
    public static byte[] encryptByPrivateKey(byte[] data, String key)
            throws Exception {
        //      
        byte[] keyBytes = decryptBASE64(key);
 
        //     
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        Key privateKey = keyFactory.generatePrivate(pkcs8KeySpec);
 
        //      
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.ENCRYPT_MODE, privateKey);
 
        return cipher.doFinal(data);
    }
 
    /**
     *     
     * 
     * @param keyMap
     * @return
     * @throws Exception
     */
    public static String getPrivateKey(Map keyMap)
            throws Exception {
        Key key = (Key) keyMap.get(PRIVATE_KEY);
 
        return encryptBASE64(key.getEncoded());
    }
 
    /**
     *     
     * 
     * @param keyMap
     * @return
     * @throws Exception
     */
    public static String getPublicKey(Map keyMap)
            throws Exception {
        Key key = (Key) keyMap.get(PUBLIC_KEY);
 
        return encryptBASE64(key.getEncoded());
    }
 
    /**
     *      
     * 
     * @return
     * @throws Exception
     */
    public static Map initKey() throws Exception {
        KeyPairGenerator keyPairGen = KeyPairGenerator
                .getInstance(KEY_ALGORITHM);
        keyPairGen.initialize(1024);
 
        KeyPair keyPair = keyPairGen.generateKeyPair();
 
        //   
        RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
 
        //   
        RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
 
        Map keyMap = new HashMap(2);
 
        keyMap.put(PUBLIC_KEY, publicKey);
        keyMap.put(PRIVATE_KEY, privateKey);
        return keyMap;
    }
}
  
 참고           각종 암호 화 알고리즘
                               MD5 암호 화 에 대해 서 얘 기해 보 겠 습 니 다.