자바 에서 RSA 암호 화 복호화 의 실현 방법 분석

이 글 의 사례 는 자바 에서 RSA 암호 화 복호화 의 실현 방법 을 서술 하 였 다.여러분 께 참고 하도록 공유 하 겠 습 니 다.구체 적 으로 는 다음 과 같 습 니 다.

public static void main(String[] args) throws Exception {
    // TODO Auto-generated method stub
    HashMap<String, Object> map = RSAUtils.getKeys();
    //       
    RSAPublicKey publicKey = (RSAPublicKey) map.get("public");
    RSAPrivateKey privateKey = (RSAPrivateKey) map.get("private");
    // 
    String modulus = publicKey.getModulus().toString();
    //    
    String public_exponent = publicKey.getPublicExponent().toString();
    //    
    String private_exponent = privateKey.getPrivateExponent().toString();
    //  
    String ming = "123456789";
    //             
    RSAPublicKey pubKey = RSAUtils.getPublicKey(modulus, public_exponent);
    RSAPrivateKey priKey = RSAUtils.getPrivateKey(modulus, private_exponent);
    //      
    String mi = RSAUtils.encryptByPublicKey(ming, pubKey);
    System.err.println(mi);
    //      
    ming = RSAUtils.decryptByPrivateKey(mi, priKey);
    System.err.println(ming);
}

RSAUtils.Java

package yyy.test.rsa;
import java.math.BigInteger;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.NoSuchAlgorithmException;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.RSAPrivateKeySpec;
import java.security.spec.RSAPublicKeySpec;
import java.util.HashMap;
import javax.crypto.Cipher;
public class RSAUtils {
  /**
   *        
   * @throws NoSuchAlgorithmException
   *
   */
  public static HashMap<String, Object> getKeys() throws NoSuchAlgorithmException{
    HashMap<String, Object> map = new HashMap<String, Object>();
    KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA");
    keyPairGen.initialize(1024);
    KeyPair keyPair = keyPairGen.generateKeyPair();
    RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
    RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
    map.put("public", publicKey);
    map.put("private", privateKey);
    return map;
  }
  /**
   *         RSA  
   *   ：【           ， RSA/None/PKCS1Padding，  JDK           ， Android   RSA
   * /None/NoPadding】
   *
   * @param modulus
   *       
   * @param exponent
   *        
   * @return
   */
  public static RSAPublicKey getPublicKey(String modulus, String exponent) {
    try {
      BigInteger b1 = new BigInteger(modulus);
      BigInteger b2 = new BigInteger(exponent);
      KeyFactory keyFactory = KeyFactory.getInstance("RSA");
      RSAPublicKeySpec keySpec = new RSAPublicKeySpec(b1, b2);
      return (RSAPublicKey) keyFactory.generatePublic(keySpec);
    } catch (Exception e) {
      e.printStackTrace();
      return null;
    }
  }
  /**
   *         RSA  
   *   ：【           ， RSA/None/PKCS1Padding，  JDK           ， Android   RSA
   * /None/NoPadding】
   *
   * @param modulus
   *       
   * @param exponent
   *        
   * @return
   */
  public static RSAPrivateKey getPrivateKey(String modulus, String exponent) {
    try {
      BigInteger b1 = new BigInteger(modulus);
      BigInteger b2 = new BigInteger(exponent);
      KeyFactory keyFactory = KeyFactory.getInstance("RSA");
      RSAPrivateKeySpec keySpec = new RSAPrivateKeySpec(b1, b2);
      return (RSAPrivateKey) keyFactory.generatePrivate(keySpec);
    } catch (Exception e) {
      e.printStackTrace();
      return null;
    }
  }
  /**
   *     
   *
   * @param data
   * @param publicKey
   * @return
   * @throws Exception
   */
  public static String encryptByPublicKey(String data, RSAPublicKey publicKey)
      throws Exception {
    Cipher cipher = Cipher.getInstance("RSA");
    cipher.init(Cipher.ENCRYPT_MODE, publicKey);
    //   
    int key_len = publicKey.getModulus().bitLength() / 8;
    //        <=   -11
    String[] datas = splitString(data, key_len - 11);
    String mi = "";
    //          -11      
    for (String s : datas) {
      mi += bcd2Str(cipher.doFinal(s.getBytes()));
    }
    return mi;
  }
  /**
   *     
   *
   * @param data
   * @param privateKey
   * @return
   * @throws Exception
   */
  public static String decryptByPrivateKey(String data, RSAPrivateKey privateKey)
      throws Exception {
    Cipher cipher = Cipher.getInstance("RSA");
    cipher.init(Cipher.DECRYPT_MODE, privateKey);
    //  
    int key_len = privateKey.getModulus().bitLength() / 8;
    byte[] bytes = data.getBytes();
    byte[] bcd = ASCII_To_BCD(bytes, bytes.length);
    System.err.println(bcd.length);
    //                
    String ming = "";
    byte[][] arrays = splitArray(bcd, key_len);
    for(byte[] arr : arrays){
      ming += new String(cipher.doFinal(arr));
    }
    return ming;
  }
  /**
   * ASCII  BCD 
   *
   */
  public static byte[] ASCII_To_BCD(byte[] ascii, int asc_len) {
    byte[] bcd = new byte[asc_len / 2];
    int j = 0;
    for (int i = 0; i < (asc_len + 1) / 2; i++) {
      bcd[i] = asc_to_bcd(ascii[j++]);
      bcd[i] = (byte) (((j >= asc_len) ? 0x00 : asc_to_bcd(ascii[j++])) + (bcd[i] << 4));
    }
    return bcd;
  }
  public static byte asc_to_bcd(byte asc) {
    byte bcd;
    if ((asc >= '0') && (asc <= '9'))
      bcd = (byte) (asc - '0');
    else if ((asc >= 'A') && (asc <= 'F'))
      bcd = (byte) (asc - 'A' + 10);
    else if ((asc >= 'a') && (asc <= 'f'))
      bcd = (byte) (asc - 'a' + 10);
    else
      bcd = (byte) (asc - 48);
    return bcd;
  }
  /**
   * BCD    
   */
  public static String bcd2Str(byte[] bytes) {
    char temp[] = new char[bytes.length * 2], val;
    for (int i = 0; i < bytes.length; i++) {
      val = (char) (((bytes[i] & 0xf0) >> 4) & 0x0f);
      temp[i * 2] = (char) (val > 9 ? val + 'A' - 10 : val + '0');
      val = (char) (bytes[i] & 0x0f);
      temp[i * 2 + 1] = (char) (val > 9 ? val + 'A' - 10 : val + '0');
    }
    return new String(temp);
  }
  /**
   *      
   */
  public static String[] splitString(String string, int len) {
    int x = string.length() / len;
    int y = string.length() % len;
    int z = 0;
    if (y != 0) {
      z = 1;
    }
    String[] strings = new String[x + z];
    String str = "";
    for (int i=0; i<x+z; i++) {
      if (i==x+z-1 && y!=0) {
        str = string.substring(i*len, i*len+y);
      }else{
        str = string.substring(i*len, i*len+len);
      }
      strings[i] = str;
    }
    return strings;
  }
  /**
   *    
   */
  public static byte[][] splitArray(byte[] data,int len){
    int x = data.length / len;
    int y = data.length % len;
    int z = 0;
    if(y!=0){
      z = 1;
    }
    byte[][] arrays = new byte[x+z][];
    byte[] arr;
    for(int i=0; i<x+z; i++){
      arr = new byte[len];
      if(i==x+z-1 && y!=0){
        System.arraycopy(data, i*len, arr, 0, y);
      }else{
        System.arraycopy(data, i*len, arr, 0, len);
      }
      arrays[i] = arr;
    }
    return arrays;
  }
}

java

Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");

android

Cipher cipher = Cipher.getInstance("RSA/ECB/NoPadding");

참고:
http://stackoverflow.com/questions/6069369/rsa-encryption-difference-between-java-and-android
http://stackoverflow.com/questions/2956647/rsa-encrypt-with-base64-encoded-public-key-in-android
추가:RSA 알고리즘 키 길이/비밀문서 길이/명문 길이
1.키 길이
rsa 알고리즘 을 초기 화 할 때 키 길 이 를 96-1024 bits 사이 에 입력 합 니 다.
(1)왜 하한 선 이 96bits(12bytes)입 니까?1byte 의 명문 을 암호 화하 기 위해 서 는 최소한 1+11=12bytes 의 키 가 필요 합 니 다(모 르 시 겠 습 니까?아래 의 명문 길 이 를 보 세 요)하한 선 96bits 보다 낮 을 때 하나의 byte 도 암호 화 할 수 없 으 니 당연히 의미 가 없습니다.
(2)왜 상한 선 이 1024(128 bytes)입 니까?이것 은 알고리즘 자체 가 결정 한 것 입 니 다.물론 어느 날 인터넷 에 2048 bits 길이 의 키 를 지원 하 는 rsa 알고리즘 이 나 오 면 쓸데없는 말 을 하 세 요.
2.명문 길이
명문 길이(bytes)<=키 길이(bytes)-11.그러면 상한 키 길이 1024 bits 에 암호 화 할 수 있 는 명문 상한 선 은 117 bytes 입 니 다.
이 규정 은 매우 막장 이기 때문에 블록 버스터 암호 화가 나 타 났 다.인터넷 에서 이 버 전이 유행 하고 있다.매우 간단 하 다.만약 에 명문 길이 가 그 최대 명문 길이 보다 크 면 나 는 블록 버스터 로 나 누 어 모든 조각 이 그 값 을 초과 하지 않도록 보장 하면 된다.
조각 수=(명문 길이(bytes)/(키 길이(bytes)-11)의 정수 부분+1 은 한 조각 이 아 닌 한 조각 으로 계산 합 니 다.
3.비밀문서 길이
네,바로 이 소문 으로 가득 차 있 습 니 다.모두 비밀문서 의 길 이 는 키 길이 의 절반 이 라 고 합 니 다.제 가 검증 한 결과 비밀문서 의 길 이 는 키 길이 와 같 습 니 다.물론 이것 은 조각 을 가리 지 않 는 상황 입 니 다.
조각 을 나 눈 후 암호 길이=키 길이*조각 수
예 를 들 어 96bits 키,명문 4bytes
각 명문 의 길이=96/8-11=1byte,편수=4,비밀문 의 길이=96/8*4=48bytes
예 를 들 어 128 bits 키,명문 8bytes
각 명문 길이=128/8-11=5bytes,편수=8/5 취 정+1=2,비밀문 길이=128/8*2=32
지정 한 길이 의 명문 에 대해 서 는 암호 길이 와 키 길이 가 정비례 관계 가 아 닙 니 다.예 를 들 어 4bytes 의 명문,가장 짧 은 키 96bites 는 암호 길이 48bytes,128 bits 미터 키 일 때 암호 길이 가 16bytes,1024 bits 키 일 때 암호 길이 128 bytes 입 니 다.
필름 을 많이 나 눌 수록 비밀문서 의 길이 가 커 질 수 있 기 때문에 1024 bits 키 를 계속 사용 하 라 는 말 이 있 습 니 다.제발,현재 기 계 는 1024 bits 키 를 계산 하 는 데 시간 이 필요 합 니 다.cpu 가 대단 하 다 고 생각 하지 마 세 요.그럼 어떤 값 을 선택 하 는 것 이 좋 을까요?개인 적 으로 600 bits 라 고 생각 합 니 다.왜냐하면 우 리 는 하나의 문자열 에 대한 암호 화 는 직접 암호 화 하 는 것 이 아니 라 문자열 hash 를 암호 화 하 는 것 입 니 다.현재 hash 값 은 보통 4bytes 이 고 8bytes 가 거의 없 기 때문에 몇 십 년 동안 64bytes 를 초과 하지 않 을 것 입 니 다.그럼 64bytes 로 계산 하 세 요.키 길 이 는(64+11)*8=600 bits 입 니 다.
오픈 소스 rsa 알고리즘 을 사용 할 때 주의해 야 합 니 다.그 시대 의 사람들 은 log 를 4bytes 로 사용 하 였 는데,지금 은 64 비트 의 기계 에 놓 으 면 순환 이 죽 습 니 다.얼마나 슬 프 고 재촉 하 는 지...........................................이 순환 이 들 어가 면 한 시간 도 못 나 오 니까........................................................................
PS:암호 화 복호화 에 관심 이 있 는 친 구 는 본 사이트 의 온라인 도 구 를 참고 할 수 있 습 니 다.
텍스트 온라인 암호 화 복호화 도구(AES,DES,RC4 등 포함):
http://tools.jb51.net/password/txt_encode
MD5 온라인 암호 화 도구:
http://tools.jb51.net/password/CreateMD5Password
온라인 해시/해시 알고리즘 암호 화 도구:
http://tools.jb51.net/password/hash_encrypt
온라인 MD5/hash/SHA-1/SHA-2/SHA-256/SHA-512/SHA-3/RIPEMD-160 암호 화 도구:
http://tools.jb51.net/password/hash_md5_sha
온라인 sha 1/sha 224/sha 256/sha 384/sha 512 암호 화 도구:
http://tools.jb51.net/password/sha_encode
자바 관련 내용 에 관심 이 있 는 독자 들 은 본 사이트 의 주 제 를 볼 수 있 습 니 다.
본 고 에서 말 한 것 이 여러분 의 자바 프로 그래 밍 에 도움 이 되 기 를 바 랍 니 다.