Android 는 RSA 암호 화 를 사용 하여 인터페이스 호출 시 검사 기능 을 구현 합 니 다.

RSA 알고리즘 은 비대 칭 암호 화 알고리즘 인 데 비대 칭 암호 화 알고리즘 은 무엇 입 니까?
일반적으로 우리 가 이해 하 는 암호 화 는 이렇게 진행 된다.원문 은 열쇠(키)암호 화 를 거 쳐 비밀문서 가 된 다음 에 비밀문 을 수신 자 에 게 전달 하고 수신 자 는 이 열쇠(키)로 비밀문 을 풀 었 다.이 과정 에서 암호 화 와 복호화 가 같은 열 쇠 를 사 용 했 는데 이런 암호 화 방식 을 대칭 암호 화 라 고 부른다.
비대 칭 암호 화 는 대칭 암호 화 와 상대 적 으로 암호 화 에 사용 되 는 열쇠 와 복호화 에 사용 되 는 열 쇠 는 같은 열쇠 가 아니다.비대 칭 암호 화 는 먼저 두 개의 열 쇠 를 만 들 고 이 두 열 쇠 는 쌍 을 이 루어 각각 공개 키 와 비밀 키 라 고 부른다.암호 화 를 할 때 우 리 는 공개 키 를 사용 하여 암호 화 를 하고 복호화 할 때 비밀 키 를 사용 해 야 복호화 할 수 있 습 니 다.이것 이 바로 비대 칭 암호 화 알고리즘 입 니 다.
만약 에 비대 칭 암호 화 를 사용 하면 갑 은 을 에 게 메 시 지 를 보낸다.이때 을 은 두 개의 열 쇠 를 미리 만 들 고 비밀 키 을 은 스스로 저장 한 다음 에 공개 키 를 갑 에 게 보 내 고 갑 은 공개 키 를 사용 하여 정 보 를 암호 화한 다음 에 을 에 게 전달한다.마지막 으로 을 은 자신의 비밀 키 를 사용 하여 데 이 터 를 복호화 한다.이 과정 에서 공개 키 는 제3자 에 의 해 캡 처 될 수 있 지만 다른 것 은 이 제3자 가 공개 키 를 얻 더 라 도 비밀 문 서 를 풀 수 없다 는 것 이다.비밀 문 서 를 해독 하 는 데 필요 한 비밀 키 는 처음부터 끝까지 을 의 손 에 있 기 때문이다.그래서 이 과정 은 안전 하 다.
안 드 로 이 드 애플 리 케 이 션 에서 녹음 이 끝 난 후 녹음 파일 을 SpringBoot 가 만 든 배경 인터페이스 에 업로드 합 니 다.
Android 응용 프로그램 에 로그 인 기능 이 없 기 때문에 사용자 정의 문자열 을 암호 화하 고 전송 한 다음 SpringBoot 배경 에서 복호화 검증 을 해 야 합 니 다.업로드 인터페이스 노출 방지.
이루어지다
우선 SpringBoot 엔 드 에 RsaUtils 도구 클래스 를 새로 만 듭 니 다.

import com.sun.org.apache.xerces.internal.impl.dv.util.Base64;
import java.io.ByteArrayOutputStream;
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.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.Base64;

import javax.crypto.Cipher;

//java   
public class RsaUtils {
 //  
 public static String privateKey = "       ";
 //  
 private static String publicKey = "       ";
 /**
  * RSA        
  */
 private static final int MAX_ENCRYPT_BLOCK = 117;

 /**
  * RSA        
  */
 private static final int MAX_DECRYPT_BLOCK = 128;

 /**
  *      
  *
  * @return    
  */
 public static KeyPair getKeyPair() throws Exception {
  KeyPairGenerator generator = KeyPairGenerator.getInstance("RSA");
  generator.initialize(1024);
  return generator.generateKeyPair();
 }

 /**
  *     
  *
  * @param privateKey      
  * @return
  */
 public static PrivateKey getPrivateKey(String privateKey) throws Exception {
  KeyFactory keyFactory = KeyFactory.getInstance("RSA");

  byte[] decodedKey = com.sun.org.apache.xerces.internal.impl.dv.util.Base64.decode(new String(privateKey.getBytes()));
  PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(decodedKey);
  return keyFactory.generatePrivate(keySpec);
 }

 /**
  *     
  *
  * @param publicKey      
  * @return
  */
 public static PublicKey getPublicKey(String publicKey) throws Exception {
  KeyFactory keyFactory = KeyFactory.getInstance("RSA");
  byte[] decodedKey = Base64.decode(publicKey);
  X509EncodedKeySpec keySpec = new X509EncodedKeySpec(decodedKey);
  return keyFactory.generatePublic(keySpec);
 }

 /**
  * RSA  
  *
  * @param data       
  * @param publicKey   
  * @return
  */
 public static String encrypt(String data, PublicKey publicKey) throws Exception {
  Cipher cipher = Cipher.getInstance("RSA");
  cipher.init(Cipher.ENCRYPT_MODE, publicKey);
  int inputLen = data.getBytes().length;
  ByteArrayOutputStream out = new ByteArrayOutputStream();
  int offset = 0;
  byte[] cache;
  int i = 0;
  //        
  while (inputLen - offset > 0) {
   if (inputLen - offset > MAX_ENCRYPT_BLOCK) {
    cache = cipher.doFinal(data.getBytes(), offset, MAX_ENCRYPT_BLOCK);
   } else {
    cache = cipher.doFinal(data.getBytes(), offset, inputLen - offset);
   }
   out.write(cache, 0, cache.length);
   i++;
   offset = i * MAX_ENCRYPT_BLOCK;
  }
  byte[] encryptedData = out.toByteArray();
  out.close();
  //         base64    ,  UTF-8         
  //        
  return new String(Base64.encode((encryptedData)));
 }

 /**
  * RSA  
  *
  * @param data       
  * @param privateKey   
  * @return
  */
 public static String decrypt(String data, PrivateKey privateKey) throws Exception {

  Cipher cipher = Cipher.getInstance("RSA");
  cipher.init(Cipher.DECRYPT_MODE, privateKey);
  byte[] dataBytes = Base64.decode(data);
  int inputLen = dataBytes.length;
  ByteArrayOutputStream out = new ByteArrayOutputStream();
  int offset = 0;
  byte[] cache;
  int i = 0;
  //        
  while (inputLen - offset > 0) {
   if (inputLen - offset > MAX_DECRYPT_BLOCK) {
    cache = cipher.doFinal(dataBytes, offset, MAX_DECRYPT_BLOCK);
   } else {
    cache = cipher.doFinal(dataBytes, offset, inputLen - offset);
   }
   out.write(cache, 0, cache.length);
   i++;
   offset = i * MAX_DECRYPT_BLOCK;
  }
  byte[] decryptedData = out.toByteArray();
  out.close();
  //       
  return new String(decryptedData, "UTF-8");
 }

 /**
  *   
  *
  * @param data       
  * @param privateKey   
  * @return   
  */
 public static String sign(String data, PrivateKey privateKey) throws Exception {
  byte[] keyBytes = privateKey.getEncoded();
  PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(keyBytes);
  KeyFactory keyFactory = KeyFactory.getInstance("RSA");
  PrivateKey key = keyFactory.generatePrivate(keySpec);
  Signature signature = Signature.getInstance("MD5withRSA");
  signature.initSign(key);
  signature.update(data.getBytes());
  return Base64.encode(signature.sign());
 }

 /**
  *   
  *
  * @param srcData      
  * @param publicKey   
  * @param sign    
  * @return       
  */
 public static boolean verify(String srcData, PublicKey publicKey, String sign) throws Exception {
  byte[] keyBytes = publicKey.getEncoded();
  X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
  KeyFactory keyFactory = KeyFactory.getInstance("RSA");
  PublicKey key = keyFactory.generatePublic(keySpec);
  Signature signature = Signature.getInstance("MD5withRSA");
  signature.initVerify(key);
  signature.update(srcData.getBytes());
  return signature.verify(Base64.decode(sign));
 }


/* public static void main(String[] args) {
  try {
   //      
   KeyPair keyPair = getKeyPair();
   String privateKey = new String(Base64.getEncoder().encode(keyPair.getPrivate().getEncoded()));
   String publicKey = new String(Base64.getEncoder().encode(keyPair.getPublic().getEncoded()));
   System.out.println("  :" + privateKey);
   System.out.println("  :" + publicKey);


   // RSA  
*//*   String data = "        ";
   String encryptData = encrypt(data, getPublicKey(publicKey));
   System.out.println("     :" + encryptData);
   // RSA  
   String decryptData = decrypt("encryptData ", getPrivateKey(privateKey));
   System.out.println("     :" + decryptData);

   // RSA  
   String sign = sign(data, getPrivateKey(privateKey));
   // RSA  
   boolean result = verify(data, getPublicKey(publicKey), sign);
   System.out.print("    :" + result);*//*
  } catch (Exception e) {
   e.printStackTrace();
   System.out.print("     ");
  }
 }*/

}

그리고 이 도구 류 의 main 방법 에서 키 쌍 을 만 드 는 방법 을 실행 하여 생 성 된 공개 키 와 키 쌍 을 가 져 옵 니 다.

그리고 맨 위 에 있 는 privateKey 와 publicKey 에 값 을 부여 합 니 다.
그리고 Android 쪽 에 도 도구 클래스 RsaUtils 를 새로 만 듭 니 다.

package com.badao.badaoimclient.common;

import android.util.Base64;
import java.io.ByteArrayOutputStream;
import java.security.KeyFactory;
import java.security.PublicKey;
import java.security.spec.X509EncodedKeySpec;
import javax.crypto.Cipher;

public class RsaUtils{

 //  
 public static String publicKey=" Java      ";
 /**
  * RSA        
  */
 private static final int MAX_ENCRYPT_BLOCK = 117;

 /**
  * RSA        
  */
 private static final int MAX_DECRYPT_BLOCK = 128;

 

 /**
  *     
  *
  * @param publicKey      
  * @return
  */
 public static PublicKey getPublicKey(String publicKey) throws Exception {
  KeyFactory keyFactory = KeyFactory.getInstance("RSA");
  byte[] decodedKey =Base64.decode(publicKey.getBytes(), Base64.DEFAULT);
  X509EncodedKeySpec keySpec = new X509EncodedKeySpec(decodedKey);
  return keyFactory.generatePublic(keySpec);
 }

 /**
  * RSA  
  *
  * @param data      
  * @param publicKey   
  * @return
  */
 public static String encrypt(String data, PublicKey publicKey) throws Exception {
  Cipher cipher ;
  cipher= Cipher.getInstance("RSA/ECB/PKCS1Padding");
  cipher.init(Cipher.ENCRYPT_MODE, publicKey);
  int inputLen = data.getBytes().length;
  ByteArrayOutputStream out = new ByteArrayOutputStream();
  int offset = 0;
  byte[] cache;
  int i = 0;
  //        
  while (inputLen - offset > 0) {
   if (inputLen - offset > MAX_ENCRYPT_BLOCK) {
    cache = cipher.doFinal(data.getBytes(), offset, MAX_ENCRYPT_BLOCK);
   } else {
    cache = cipher.doFinal(data.getBytes(), offset, inputLen - offset);
   }
   out.write(cache, 0, cache.length);
   i++;
   offset = i * MAX_ENCRYPT_BLOCK;
  }
  byte[] encryptedData = out.toByteArray();
  out.close();
  //         base64    ,  UTF-8         
  //        
  return new String(Base64.encode(encryptedData, Base64.DEFAULT));
 }

}

이곳 의 공개 키 는 위 에서 생 성 된 공개 키 와 일치 합 니 다.
두 공구 류 의 차 이 를 주의 하고 있다.
Android 도구 클래스 의 Base 64 에 도 입 된 것 은?
import android.util.Base64;
자바 에 도 입 된 Base 64 는
import com.sun.org.apache.xerces.internal.impl.dv.util.Base64;
자바.util.Base 64 를 인용 하지 않 은 이 유 는 줄 바 꿈 으로 인 한 이동 문자 문제 가 있 기 때 문 입 니 다.
그리고 Android 에서 문자열 을 암호 화 합 니 다.

//       
String escode = "";
try {
  escode = RsaUtils.encrypt(key,RsaUtils.getPublicKey(RsaUtils.publicKey));
 } catch (Exception e) {
  e.printStackTrace();
}

인터페이스 로 호출 된 매개 변 수 를 자바 에 전달 하여 복호화 합 니 다.

if(decode.equals(RsaUtils.decrypt(key,RsaUtils.getPrivateKey(RsaUtils.privateKey))))
  {
   try
   {
    //       
    String filePath = RuoYiConfig.getUploadPath();
    //           
    String fileName = FileUploadUtils.upload(filePath, file);
    String url = serverConfig.getUrl() + fileName;
    AjaxResult ajax = AjaxResult.success();
    ajax.put("fileName", fileName);
    ajax.put("url", url);
    return ajax;
   }
   catch (Exception e)
   {
    return AjaxResult.error(e.getMessage());
   }
  }else {
   return AjaxResult.error("    ");
  }

이렇게 하면 지정 한 이동 단 을 통 해 파일 업로드 인터페이스 에 만 접근 할 수 있 도록 제한 합 니 다.
이동 단 호출 인터페이스 에서 테스트

보 이 는 호출 인터페이스 전 암호 화 성공
또한 배경 인터페이스의 복호화 검 사 를 사용 할 수 있 습 니 다.

이렇게 다른 제3자 요청 인 터 페 이 스 는 요청 할 수 없습니다.

이상 은 안 드 로 이 드 가 RSA 암호 화 를 사용 하여 인터페이스 호출 을 실현 할 때의 검사 기능 에 대한 상세 한 내용 입 니 다.안 드 로 이 드 rsa 암호 화 인터페이스 호출 에 관 한 자 료 는 다른 관련 글 을 주목 하 십시오!