508 lines
19 KiB
Markdown
508 lines
19 KiB
Markdown
Java의 `java.security` 패키지는 **보안 관련 기능**을 제공하는 핵심 패키지야. 크게 다음과 같은 기능들로 분류할 수 있어:
|
|
|
|
---
|
|
|
|
## 1. 암호화(Encryption) 및 복호화(Decryption)
|
|
암호화는 데이터를 보호하는 데 중요한 역할을 해. Java에서는 다양한 알고리즘을 지원하는 **JCA(Java Cryptography Architecture)** 및 **JCE(Java Cryptography Extension)**를 통해 암호화 기능을 제공해.
|
|
|
|
- **주요 클래스 및 인터페이스**
|
|
| 클래스/인터페이스 | 설명 |
|
|
|------------------|------|
|
|
| `Cipher` | 암호화 및 복호화 작업을 수행하는 클래스 |
|
|
| `KeyGenerator` | 대칭 키를 생성하는 클래스 (AES, DES 등) |
|
|
| `SecretKey` | 대칭 키를 나타내는 인터페이스 |
|
|
| `KeyPairGenerator` | 공개 키 및 개인 키 쌍을 생성하는 클래스 |
|
|
| `PublicKey`, `PrivateKey` | 비대칭 키를 나타내는 인터페이스 |
|
|
|
|
- **예제: AES 암호화 및 복호화**
|
|
```java
|
|
import javax.crypto.Cipher;
|
|
import javax.crypto.KeyGenerator;
|
|
import javax.crypto.SecretKey;
|
|
import java.util.Base64;
|
|
|
|
public class AESExample {
|
|
public static void main(String[] args) throws Exception {
|
|
KeyGenerator keyGen = KeyGenerator.getInstance("AES");
|
|
keyGen.init(128); // 128비트 키 생성
|
|
SecretKey secretKey = keyGen.generateKey();
|
|
|
|
Cipher cipher = Cipher.getInstance("AES");
|
|
cipher.init(Cipher.ENCRYPT_MODE, secretKey);
|
|
|
|
String plaintext = "Hello, Security!";
|
|
byte[] encrypted = cipher.doFinal(plaintext.getBytes());
|
|
|
|
System.out.println("Encrypted: " + Base64.getEncoder().encodeToString(encrypted));
|
|
|
|
// 복호화
|
|
cipher.init(Cipher.DECRYPT_MODE, secretKey);
|
|
byte[] decrypted = cipher.doFinal(encrypted);
|
|
System.out.println("Decrypted: " + new String(decrypted));
|
|
}
|
|
}
|
|
```
|
|
|
|
---
|
|
|
|
## 2. 키(Key) 및 키스토어(KeyStore) 관리
|
|
보안 키를 안전하게 저장하고 관리할 수 있도록 **키스토어** 기능을 제공해.
|
|
|
|
- **주요 클래스 및 인터페이스**
|
|
| 클래스/인터페이스 | 설명 |
|
|
|------------------|------|
|
|
| `KeyStore` | 키 및 인증서를 저장하는 저장소 |
|
|
| `KeyFactory` | 키 객체를 생성하는 클래스 |
|
|
| `KeyPair` | 공개 키와 개인 키를 함께 저장하는 클래스 |
|
|
|
|
- **예제: KeyStore 생성 및 저장**
|
|
```java
|
|
import java.io.FileOutputStream;
|
|
import java.security.KeyStore;
|
|
|
|
public class KeyStoreExample {
|
|
public static void main(String[] args) throws Exception {
|
|
KeyStore keyStore = KeyStore.getInstance("JKS");
|
|
keyStore.load(null, null); // 새로운 KeyStore 생성
|
|
|
|
try (FileOutputStream fos = new FileOutputStream("keystore.jks")) {
|
|
keyStore.store(fos, "password".toCharArray()); // 비밀번호와 함께 저장
|
|
}
|
|
System.out.println("KeyStore 저장 완료");
|
|
}
|
|
}
|
|
```
|
|
|
|
---
|
|
|
|
## 3. 해시(Hashing) 및 메시지 다이제스트(Message Digest)
|
|
해시는 데이터를 변환하여 무결성을 검증하는 데 사용돼. 대표적인 알고리즘으로 **SHA-256**, **MD5** 등이 있어.
|
|
|
|
- **주요 클래스**
|
|
| 클래스 | 설명 |
|
|
|--------|------|
|
|
| `MessageDigest` | 해시 값을 생성하는 클래스 |
|
|
| `DigestInputStream` | 스트림을 통해 해시 계산을 수행하는 클래스 |
|
|
|
|
- **예제: SHA-256 해싱**
|
|
```java
|
|
import java.security.MessageDigest;
|
|
import java.util.Base64;
|
|
|
|
public class HashExample {
|
|
public static void main(String[] args) throws Exception {
|
|
String input = "password123";
|
|
MessageDigest digest = MessageDigest.getInstance("SHA-256");
|
|
byte[] hash = digest.digest(input.getBytes());
|
|
|
|
System.out.println("SHA-256 Hash: " + Base64.getEncoder().encodeToString(hash));
|
|
}
|
|
}
|
|
```
|
|
|
|
---
|
|
|
|
## 4. 전자서명(Digital Signature)
|
|
전자서명은 데이터의 **무결성을 검증**하고 **서명자의 신원**을 확인하는 데 사용돼.
|
|
|
|
- **주요 클래스 및 인터페이스**
|
|
| 클래스/인터페이스 | 설명 |
|
|
|------------------|------|
|
|
| `Signature` | 전자서명을 생성하고 검증하는 클래스 |
|
|
| `KeyPairGenerator` | 전자서명을 위한 키 쌍을 생성하는 클래스 |
|
|
|
|
- **예제: 전자서명 생성 및 검증**
|
|
```java
|
|
import java.security.*;
|
|
|
|
public class DigitalSignatureExample {
|
|
public static void main(String[] args) throws Exception {
|
|
KeyPairGenerator keyGen = KeyPairGenerator.getInstance("RSA");
|
|
keyGen.initialize(2048);
|
|
KeyPair keyPair = keyGen.generateKeyPair();
|
|
|
|
Signature signature = Signature.getInstance("SHA256withRSA");
|
|
signature.initSign(keyPair.getPrivate());
|
|
|
|
String message = "This is a secure message.";
|
|
signature.update(message.getBytes());
|
|
byte[] signedData = signature.sign();
|
|
|
|
// 검증
|
|
signature.initVerify(keyPair.getPublic());
|
|
signature.update(message.getBytes());
|
|
boolean isVerified = signature.verify(signedData);
|
|
System.out.println("Signature Verified: " + isVerified);
|
|
}
|
|
}
|
|
```
|
|
|
|
---
|
|
|
|
## 5. 인증(Authentication) 및 접근 제어(Access Control)
|
|
사용자의 인증 및 권한 관리를 할 수 있도록 지원해.
|
|
|
|
- **주요 클래스 및 인터페이스**
|
|
| 클래스/인터페이스 | 설명 |
|
|
|------------------|------|
|
|
| `AccessController` | 접근 제어를 수행하는 클래스 |
|
|
| `Permission` | 특정 작업에 대한 권한을 나타내는 클래스 |
|
|
| `Policy` | 보안 정책을 관리하는 클래스 |
|
|
|
|
- **예제: 접근 제어 실행**
|
|
```java
|
|
import java.security.AccessController;
|
|
import java.security.PrivilegedAction;
|
|
|
|
public class AccessControlExample {
|
|
public static void main(String[] args) {
|
|
String result = AccessController.doPrivileged((PrivilegedAction<String>) () -> {
|
|
return System.getProperty("user.home");
|
|
});
|
|
System.out.println("User Home Directory: " + result);
|
|
}
|
|
}
|
|
```
|
|
|
|
---
|
|
|
|
## 6. 난수 생성(Secure Random)
|
|
보안에 강한 난수를 생성하는 기능도 제공해.
|
|
|
|
- **주요 클래스**
|
|
| 클래스 | 설명 |
|
|
|--------|------|
|
|
| `SecureRandom` | 보안 강도를 높인 난수 생성 클래스 |
|
|
|
|
- **예제: 난수 생성**
|
|
```java
|
|
import java.security.SecureRandom;
|
|
|
|
public class SecureRandomExample {
|
|
public static void main(String[] args) {
|
|
SecureRandom random = new SecureRandom();
|
|
int number = random.nextInt(100);
|
|
System.out.println("Secure Random Number: " + number);
|
|
}
|
|
}
|
|
```
|
|
|
|
---
|
|
|
|
## 7. 보안 프로바이더(Security Provider)
|
|
Java는 다양한 보안 알고리즘을 제공하는 **보안 프로바이더** 개념을 사용해.
|
|
|
|
- **주요 클래스 및 인터페이스**
|
|
| 클래스/인터페이스 | 설명 |
|
|
|------------------|------|
|
|
| `Security` | 보안 프로바이더를 관리하는 클래스 |
|
|
| `Provider` | 특정 보안 기능을 제공하는 클래스 |
|
|
|
|
- **예제: 설치된 보안 프로바이더 목록 출력**
|
|
```java
|
|
import java.security.Provider;
|
|
import java.security.Security;
|
|
|
|
public class SecurityProviderExample {
|
|
public static void main(String[] args) {
|
|
for (Provider provider : Security.getProviders()) {
|
|
System.out.println("Provider: " + provider.getName());
|
|
}
|
|
}
|
|
}
|
|
```
|
|
|
|
---
|
|
|
|
## 결론
|
|
Java의 `java.security` 패키지는 **암호화, 키 관리, 해싱, 전자서명, 인증, 난수 생성** 등 다양한 보안 기능을 제공해.
|
|
각 기능을 적절히 조합하면 **네트워크 보안, 파일 보호, 인증 시스템** 등을 구축할 수 있어!
|
|
|
|
|
|
|
|
|
|
---
|
|
|
|
|
|
|
|
|
|
Java의 **JCA(Java Cryptography Architecture)** 및 **JCE(Java Cryptography Extension)**에서 지원하는 주요 알고리즘을 정리해볼게.
|
|
|
|
JCA는 **암호화, 키 관리, 전자서명, 해싱** 등의 보안 기능을 정의하는 **프레임워크**이고,
|
|
JCE는 JCA를 확장하여 **대칭키 암호화, 메시지 인증 코드(MAC), 키 생성** 등을 추가 지원하는 **확장 라이브러리**야.
|
|
|
|
---
|
|
|
|
## **1. 암호화(Encryption) 및 복호화(Decryption)**
|
|
암호화는 데이터를 보호하는 가장 기본적인 보안 기술이야. JCE에서는 **대칭키 및 비대칭키 암호화**를 지원해.
|
|
|
|
| **알고리즘** | **설명** | **키 길이 (비트)** | **모드** |
|
|
|-------------|---------|-----------------|-------|
|
|
| AES (Advanced Encryption Standard) | 현대적인 대칭키 암호화 | 128, 192, 256 | ECB, CBC, CFB, OFB, GCM |
|
|
| DES (Data Encryption Standard) | 오래된 대칭키 암호화 (더 이상 안전하지 않음) | 56 | ECB, CBC, CFB, OFB |
|
|
| Triple DES (DESede) | DES를 3번 수행하여 보안성 강화 | 112, 168 | ECB, CBC, CFB, OFB |
|
|
| Blowfish | 빠르고 유연한 대칭키 알고리즘 | 32~448 | ECB, CBC, CFB, OFB |
|
|
| RSA | 비대칭키 암호화 (공개키 암호화) | 1024, 2048, 4096 | - |
|
|
| ElGamal | 공개키 기반 암호화 | 1024 이상 | - |
|
|
| ECIES (Elliptic Curve Integrated Encryption Scheme) | 타원 곡선 암호화 (ECC) | 192, 224, 256, 384, 521 | - |
|
|
|
|
**예제: AES 암호화 및 복호화**
|
|
```java
|
|
import javax.crypto.Cipher;
|
|
import javax.crypto.KeyGenerator;
|
|
import javax.crypto.SecretKey;
|
|
import java.util.Base64;
|
|
|
|
public class AESExample {
|
|
public static void main(String[] args) throws Exception {
|
|
KeyGenerator keyGen = KeyGenerator.getInstance("AES");
|
|
keyGen.init(128);
|
|
SecretKey secretKey = keyGen.generateKey();
|
|
|
|
Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
|
|
cipher.init(Cipher.ENCRYPT_MODE, secretKey);
|
|
|
|
String plaintext = "Hello, JCE!";
|
|
byte[] encrypted = cipher.doFinal(plaintext.getBytes());
|
|
|
|
System.out.println("Encrypted: " + Base64.getEncoder().encodeToString(encrypted));
|
|
}
|
|
}
|
|
```
|
|
|
|
---
|
|
|
|
## **2. 해시(Hash) 및 메시지 다이제스트(Message Digest)**
|
|
해시는 데이터를 변환하여 **무결성을 보장**하는 데 사용돼.
|
|
|
|
| **알고리즘** | **설명** | **출력 크기 (비트)** |
|
|
|-------------|---------|-----------------|
|
|
| MD5 | 오래된 해시 알고리즘 (더 이상 안전하지 않음) | 128 |
|
|
| SHA-1 | 보안 취약점이 발견된 해시 알고리즘 | 160 |
|
|
| SHA-256 | 가장 널리 사용되는 SHA-2 계열 해시 | 256 |
|
|
| SHA-512 | SHA-256보다 더 강력한 해시 | 512 |
|
|
| SHA3-256 | 최신 SHA-3 계열 해시 | 256 |
|
|
|
|
**예제: SHA-256 해싱**
|
|
```java
|
|
import java.security.MessageDigest;
|
|
import java.util.Base64;
|
|
|
|
public class SHA256Example {
|
|
public static void main(String[] args) throws Exception {
|
|
MessageDigest digest = MessageDigest.getInstance("SHA-256");
|
|
byte[] hash = digest.digest("password123".getBytes());
|
|
System.out.println("SHA-256 Hash: " + Base64.getEncoder().encodeToString(hash));
|
|
}
|
|
}
|
|
```
|
|
|
|
---
|
|
|
|
## **3. 전자서명(Digital Signature)**
|
|
전자서명은 데이터의 **무결성을 보장**하고 **서명자의 신원**을 확인하는 데 사용돼.
|
|
|
|
| **알고리즘** | **설명** | **키 길이 (비트)** |
|
|
|-------------|---------|-----------------|
|
|
| SHA1withRSA | SHA-1 기반 RSA 서명 (보안 취약) | 1024, 2048, 4096 |
|
|
| SHA256withRSA | SHA-256 기반 RSA 서명 | 2048, 4096 |
|
|
| SHA512withRSA | SHA-512 기반 RSA 서명 | 2048, 4096 |
|
|
| SHA256withECDSA | 타원 곡선 기반 전자서명 | 256, 384, 521 |
|
|
|
|
**예제: RSA 전자서명 생성 및 검증**
|
|
```java
|
|
import java.security.*;
|
|
|
|
public class DigitalSignatureExample {
|
|
public static void main(String[] args) throws Exception {
|
|
KeyPairGenerator keyGen = KeyPairGenerator.getInstance("RSA");
|
|
keyGen.initialize(2048);
|
|
KeyPair keyPair = keyGen.generateKeyPair();
|
|
|
|
Signature signature = Signature.getInstance("SHA256withRSA");
|
|
signature.initSign(keyPair.getPrivate());
|
|
|
|
String message = "Secure message";
|
|
signature.update(message.getBytes());
|
|
byte[] signedData = signature.sign();
|
|
|
|
// 검증
|
|
signature.initVerify(keyPair.getPublic());
|
|
signature.update(message.getBytes());
|
|
boolean isVerified = signature.verify(signedData);
|
|
System.out.println("Signature Verified: " + isVerified);
|
|
}
|
|
}
|
|
```
|
|
|
|
---
|
|
|
|
## **4. 메시지 인증 코드(Message Authentication Code, MAC)**
|
|
MAC은 **데이터의 무결성과 인증을 보장**하는 데 사용돼.
|
|
|
|
| **알고리즘** | **설명** | **출력 크기 (비트)** |
|
|
|-------------|---------|-----------------|
|
|
| HmacMD5 | MD5 기반 MAC | 128 |
|
|
| HmacSHA1 | SHA-1 기반 MAC | 160 |
|
|
| HmacSHA256 | SHA-256 기반 MAC | 256 |
|
|
| HmacSHA512 | SHA-512 기반 MAC | 512 |
|
|
|
|
**예제: HmacSHA256 사용**
|
|
```java
|
|
import javax.crypto.Mac;
|
|
import javax.crypto.spec.SecretKeySpec;
|
|
import java.util.Base64;
|
|
|
|
public class HmacExample {
|
|
public static void main(String[] args) throws Exception {
|
|
String key = "secret";
|
|
String message = "Hello, MAC";
|
|
|
|
Mac mac = Mac.getInstance("HmacSHA256");
|
|
mac.init(new SecretKeySpec(key.getBytes(), "HmacSHA256"));
|
|
byte[] hmac = mac.doFinal(message.getBytes());
|
|
|
|
System.out.println("HMAC: " + Base64.getEncoder().encodeToString(hmac));
|
|
}
|
|
}
|
|
```
|
|
|
|
---
|
|
|
|
## **5. 난수 생성(Secure Random)**
|
|
보안성이 높은 난수를 생성할 때 사용해.
|
|
|
|
| **알고리즘** | **설명** |
|
|
|-------------|---------|
|
|
| SHA1PRNG | 보안성이 강화된 PRNG (의사 난수 생성기) |
|
|
| NativePRNG | OS 기본 난수 생성기 사용 |
|
|
| Windows-PRNG | Windows용 PRNG |
|
|
|
|
**예제: 보안 난수 생성**
|
|
```java
|
|
import java.security.SecureRandom;
|
|
|
|
public class SecureRandomExample {
|
|
public static void main(String[] args) {
|
|
SecureRandom random = new SecureRandom();
|
|
int number = random.nextInt(100);
|
|
System.out.println("Secure Random Number: " + number);
|
|
}
|
|
}
|
|
```
|
|
|
|
---
|
|
|
|
## **결론**
|
|
JCA 및 JCE에서는 **암호화, 해시, 전자서명, MAC, 난수 생성** 등의 다양한 알고리즘을 제공해.
|
|
이들을 조합하면 **데이터 보호, 인증, 무결성 검증** 같은 강력한 보안 시스템을 구축할 수 있어!
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
---
|
|
|
|
|
|
|
|
|
|
|
|
|
|
자바의 JCA (Java Cryptography Architecture)와 JCE (Java Cryptography Extension)는 암호화와 관련된 다양한 알고리즘을 제공합니다. JCA는 기본적인 암호화 프레임워크를 제공하며, JCE는 이를 확장하여 더 강력한 암호화 기능을 추가합니다. 아래는 JCA와 JCE에서 지원되는 주요 알고리즘을 정리한 내용입니다. 이 알고리즘들은 JDK 버전에 따라 다를 수 있으니, 사용하는 JDK 버전(예: JDK 8, 11, 17 등)에 따라 지원 여부를 확인하는 것이 좋습니다.
|
|
|
|
---
|
|
|
|
### 1. **대칭키 암호화 알고리즘 (Symmetric Key Algorithms)**
|
|
- 데이터를 암호화하고 복호화할 때 동일한 키를 사용하는 알고리즘입니다.
|
|
- 대표적인 알고리즘:
|
|
- **AES (Advanced Encryption Standard)**: 128, 192, 256비트 키 지원.
|
|
- 모드: CBC, ECB, CTR, GCM 등.
|
|
- 패딩: PKCS5Padding, NoPadding 등.
|
|
- **DES (Data Encryption Standard)**: 56비트 키 (현재는 취약하여 권장되지 않음).
|
|
- **DESede (Triple DES)**: DES를 3번 반복 적용, 168비트 키.
|
|
- **Blowfish**: 가변 길이 키(최대 448비트) 지원.
|
|
- **RC2**, **RC4**: 오래된 알고리즘으로 보안성이 낮아 권장되지 않음.
|
|
|
|
---
|
|
|
|
### 2. **비대칭키 암호화 알고리즘 (Asymmetric Key Algorithms)**
|
|
- 공개키와 개인키 쌍을 사용하여 암호화와 복호화를 수행합니다.
|
|
- 대표적인 알고리즘:
|
|
- **RSA**: 키 교환, 디지털 서명, 암호화에 사용. 일반적으로 1024, 2048, 4096비트 키 길이.
|
|
- **DSA (Digital Signature Algorithm)**: 디지털 서명 전용, 1024비트 이상 권장.
|
|
- **EC (Elliptic Curve)**: 타원 곡선 암호화, 효율적인 키 크기(예: 256비트로 RSA 3072비트 수준 보안 제공).
|
|
- 예: ECDSA (서명), ECDH (키 교환).
|
|
|
|
---
|
|
|
|
### 3. **메시지 다이제스트 (해시 함수) 알고리즘**
|
|
- 데이터 무결성을 확인하기 위해 고정된 길이의 해시 값을 생성합니다.
|
|
- 대표적인 알고리즘:
|
|
- **MD5**: 128비트 출력 (현재는 충돌 취약성 때문에 권장되지 않음).
|
|
- **SHA-1**: 160비트 출력 (취약하여 더 이상 권장되지 않음).
|
|
- **SHA-2**: SHA-224, SHA-256, SHA-384, SHA-512.
|
|
- **SHA-3**: 최신 해시 알고리즘, SHA-2와 다른 구조로 보안성 강화.
|
|
|
|
---
|
|
|
|
### 4. **MAC (Message Authentication Code) 알고리즘**
|
|
- 데이터 무결성과 인증을 보장하기 위한 keyed 해시 함수입니다.
|
|
- 대표적인 알고리즘:
|
|
- **HmacMD5**: MD5 기반 HMAC (취약성 때문에 권장되지 않음).
|
|
- **HmacSHA1**: SHA-1 기반 HMAC (현재는 보안성 낮음).
|
|
- **HmacSHA256**, **HmacSHA384**, **HmacSHA512**: SHA-2 기반, 보안성 우수.
|
|
- **HmacSHA3-256**, **HmacSHA3-512**: SHA-3 기반 (JDK 9 이상에서 지원).
|
|
|
|
---
|
|
|
|
### 5. **디지털 서명 알고리즘**
|
|
- 데이터의 무결성과 출처를 보장합니다.
|
|
- 대표적인 알고리즘:
|
|
- **RSA**: SHA-1, SHA-256 등과 결합 (예: SHA256withRSA).
|
|
- **DSA**: SHA-1, SHA-256 등과 결합 (예: SHA256withDSA).
|
|
- **ECDSA**: 타원 곡선 기반 서명 (예: SHA256withECDSA).
|
|
|
|
---
|
|
|
|
### 6. **키 생성 및 키 교환 알고리즘**
|
|
- 암호화에 사용할 키를 생성하거나 교환합니다.
|
|
- 대표적인 알고리즘:
|
|
- **Diffie-Hellman (DH)**: 키 교환용.
|
|
- **ECDH**: 타원 곡선 기반 키 교환.
|
|
- 키 생성기: AES, DES, RSA, EC 등에 사용되는 `KeyGenerator` 및 `KeyPairGenerator`.
|
|
|
|
---
|
|
|
|
### 7. **기타 유틸리티**
|
|
- **Cipher**: 암호화/복호화 작업을 위한 클래스 (위의 알고리즘과 모드/패딩 조합 사용).
|
|
- **KeyStore**: 키와 인증서를 저장/관리.
|
|
- **SecureRandom**: 암호화에 적합한 난수 생성 (예: SHA1PRNG).
|
|
|
|
---
|
|
|
|
### 참고사항
|
|
- **지원 여부 확인**: JDK 버전과 제공자(Provider, 예: SunJCE, Bouncy Castle 등)에 따라 지원되는 알고리즘이 다를 수 있습니다. `Security.getProviders()`를 호출해 확인 가능.
|
|
- **보안 권장**: MD5, SHA-1, DES 등은 취약하니 최신 애플리케이션에서는 SHA-2, SHA-3, AES, RSA(2048비트 이상) 등을 사용하는 것이 좋습니다.
|
|
- **예제 코드**:
|
|
```java
|
|
import javax.crypto.Cipher;
|
|
import javax.crypto.KeyGenerator;
|
|
import java.security.Key;
|
|
|
|
public class AesExample {
|
|
public static void main(String[] args) throws Exception {
|
|
KeyGenerator keyGen = KeyGenerator.getInstance("AES");
|
|
keyGen.init(256); // 256비트 키 생성
|
|
Key key = keyGen.generateKey();
|
|
|
|
Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
|
|
cipher.init(Cipher.ENCRYPT_MODE, key);
|
|
byte[] encrypted = cipher.doFinal("Hello, World!".getBytes());
|
|
System.out.println(new String(encrypted));
|
|
}
|
|
}
|
|
```
|
|
|
|
필요하면 특정 알고리즘에 대해 더 깊이 설명하거나 예제 코드를 추가로 제공할 수 있습니다. 질문이 더 있으면 말씀해주세요! |