Android 는 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 암호 화 인터페이스 호출 에 관 한 자 료 는 다른 관련 글 을 주목 하 십시오!
이 내용에 흥미가 있습니까?
현재 기사가 여러분의 문제를 해결하지 못하는 경우 AI 엔진은 머신러닝 분석(스마트 모델이 방금 만들어져 부정확한 경우가 있을 수 있음)을 통해 가장 유사한 기사를 추천합니다:
Bitrise에서 배포 어플리케이션 설정 테스트하기이 글은 Bitrise 광고 달력의 23일째 글입니다. 자체 또는 당사 등에서 Bitrise 구축 서비스를 사용합니다. 그나저나 며칠 전 Bitrise User Group Meetup #3에서 아래 슬라이드를 발표했...
텍스트를 자유롭게 공유하거나 복사할 수 있습니다.하지만 이 문서의 URL은 참조 URL로 남겨 두십시오.
CC BY-SA 2.5, CC BY-SA 3.0 및 CC BY-SA 4.0에 따라 라이센스가 부여됩니다.