📚 목차

• 로컬 LLM이란?
• DeepSeek 모델 세팅
  • 파이썬 & 라이브러리 세팅
  • 모델 탐색 및 다운로드
  • 테스트 코드
• Fine-tuning
  • Fine-tuning 방식 비교
  • LoRA Fine-tuning 구현
• Gradio 채팅 인터페이스 구축
• 생성 붕괴 현상 및 해결

로컬 LLM이란?

로컬 LLM(Local Large Language Model)은 클라우드 서버가 아닌 자신의 컴퓨터에서 직접 실행하는 대규모 언어 모델을 말한다. ChatGPT나 Claude 같은 서비스는 인터넷을 통해 외부 서버에 요청을 보내지만, 로컬 LLM은 내 PC나 서버에서 독립적으로 작동한다.

클라우드를 사용하지 않는 이유

1. 내부 코드 유출 방지 - 민감한 데이터를 외부로 전송하지 않음
2. 오프라인 환경 지원 - 인터넷 연결 없이도 사용 가능
3. 커스터마이징 - 내부 규칙이나 정보로 파인 튜닝 가능

모델 선택 기준

이번 프로젝트에서는 다음 조건을 만족하는 모델을 찾았다:

• 상업적 이용 가능
• 한국어, 영어 지원
• 다양한 프로그래밍 언어 지원 (최신 언어 + 레거시 언어)

최종 선택: DeepSeek Coder 1.3B

성능과 환경을 고려하여 DeepSeek 모델을 선택했다. 특히 1.3B 모델은 GTX 1660 (6GB VRAM) 환경에서도 학습이 가능한 크기다.

DeepSeek 모델 세팅

파이썬 & 라이브러리 세팅

필요한 라이브러리를 설치한다.

pip install --upgrade pip

# GPU 실행 - GPU 버전에 맞게 선택
pip install torch --index-url https://download.pytorch.org/whl/cu118

# 핵심 라이브러리
pip install transformers    # 모델 로드
pip install accelerate      # device 관리
pip install sentencepiece   # 토크나이저
pip install protobuf        # 모델 config
pip install bitsandbytes    # 4bit/8bit 양자화
pip install peft           # LoRA 학습
pip install datasets       # 학습 데이터
pip install scipy          # 내부 계산
pip install einops         # 텐서 연산

모델 탐색 및 다운로드

1. Hugging Face 회원가입

https://huggingface.co/ 에 접속하여 회원가입한다.

2. 모델 선택

사용할 모델을 탐색한다. 예시: https://huggingface.co/deepseek-ai/deepseek-coder-1.3b-base

📊 선택 가이드

동일한 모델을 4bit 또는 8bit로 양자화해 로드하면 VRAM 사용량을 크게 줄여 낮은 사양의 GPU에서도 사용할 수 있으며, 일부 경우 추론 속도가 약간 느려질 수 있지만 일반적인 사용에서는 품질 저하는 거의 체감되지 않는다. ex) 7B는 RTX3080 이상에서만 사용이 가능하지만 양자화를 통해 RTX 3060로도 사용할 수 있게 해줌

3. 모델 다운로드

모델 페이지에서 "Use this model" → "Transformers" 클릭 후 예제 코드를 실행한다.

from transformers import AutoTokenizer, AutoModelForCausalLM

tokenizer = AutoTokenizer.from_pretrained("deepseek-ai/deepseek-coder-1.3b-base")
model = AutoModelForCausalLM.from_pretrained("deepseek-ai/deepseek-coder-1.3b-base")

다운로드된 모델은 다음 경로에 저장된다: C:\Users\User\.cache\huggingface\hub

테스트 코드

다운로드한 모델을 테스트한다.

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

model_name = "deepseek-ai/deepseek-coder-1.3b-base"

# 토크나이저 로드
tokenizer = AutoTokenizer.from_pretrained(
    model_name,
    trust_remote_code=True,
    local_files_only=True  # 오프라인 모드
)

# 모델 로드
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    trust_remote_code=True,
    torch_dtype=torch.float16,
    local_files_only=True
).to("cuda")

# 프롬프트 입력
prompt = "딥시크가 GPT보다 좋은 점"
inputs = tokenizer(prompt, return_tensors="pt").to("cuda")

# 텍스트 생성
with torch.no_grad():
    outputs = model.generate(
        **inputs,
        max_new_tokens=200,
        temperature=0.7,
        do_sample=True
    )

# 결과 출력
result = tokenizer.decode(outputs[0], skip_special_tokens=True)
print(result)

주요 파라미터 설명

• torch_dtype=torch.float16: GPU 메모리 절약을 위한 16bit 연산
• local_files_only=True: 오프라인 모드 (다운로드된 모델만 사용)
• max_new_tokens=200: 생성할 최대 토큰 수
• temperature=0.7: 생성 다양성 조절 (낮을수록 보수적, 높을수록 창의적)

Fine-tuning

Fine-tuning 방식 비교

Fine-tuning 방식은 크게 두 가지로 나뉜다.

Full Model Fine-tuning은 사전학습된 베이스 모델의 모든 가중치를 업데이트하는 방식이다. 모델 내부의 수십억 개 파라미터를 전부 다시 학습하므로 표현 능력을 최대한 활용할 수 있다. 하지만 VRAM 사용량이 매우 크며, 학습 시간이 오래 걸리고 데이터가 적으면 과적합 위험이 있다.

LoRA Fine-tuning은 베이스 모델의 가중치는 고정하고, Attention 등의 일부 레이어에 작은 보조 행렬(저랭크 행렬)을 추가해 그 부분만 학습한다. 즉, 전체 모델을 바꾸는 것이 아니라 "출력 경로를 보정하는 작은 어댑터"를 학습하는 방식이다.

이번 테스트에서는 LoRA Fine-tuning 방식으로 진행했다.

LoRA Fine-tuning 구현

학습 데이터 준비

학습할 데이터를 JSONL 포맷으로 작성한다.

{"instruction":"청록성의 주요 에너지원은 무엇인가?","response":"청록성의 주요 에너지원은 리움(Rium)이다."}
{"instruction":"리움은 어떤 성질을 가지고 있는가?","response":"리움은 감정에 반응해 밝기가 변하는 특성을 가진 에너지 물질이다."}
{"instruction":"청록성을 통치하는 조직은 무엇인가?","response":"청록성은 삼원 의회에 의해 통치된다."}
···

정상적으로 학습이 되었는지 확인하기 위해 AI가 알 수 없는, 현실 세계에 존재하지 않는 내용을 입력했다. (GPT로 내용 생성)

참고: 과적합(Overfitting) 문제를 방지하기 위해서는 많은 데이터를 생성해야 한다.

• 간단한 QA: 100~500건
• 도메인 특화 대화: 1,000~5,000건
• 복잡한 태스크: 10,000건 이상

LoRA 어댑터 생성

다음 코드를 통해 LoRA Adapter를 생성한다.

import torch
from datasets import load_dataset
from transformers import (
    AutoTokenizer,
    AutoModelForCausalLM,
    TrainingArguments,
    Trainer
)
from peft import LoraConfig, get_peft_model

# 1️⃣ 베이스 모델 지정
model_name = "deepseek-ai/deepseek-coder-1.3b-base"

# 2️⃣ 토크나이저 로드
tokenizer = AutoTokenizer.from_pretrained(model_name)
tokenizer.pad_token = tokenizer.eos_token

# 3️⃣ 베이스 모델 로드
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype=torch.float16,  # fp16 사용 → VRAM 절약, GTX 1660에서 필수
    device_map="auto"           # GPU 자동 할당
)

# 4️⃣ LoRA 설정
lora_config = LoraConfig(
    r=8,  
    # LoRA rank (보통 4~64 범위 사용)
    # 값 ↑ → 표현력 증가, 학습 성능 향상 가능 / VRAM 사용량 증가, 과적합 위험 ↑
    # 값 ↓ → 가볍고 안정적 / 복잡한 패턴 학습 한계
    # GTX 1660 (6GB) 기준: 8~16 권장 → 현재 8은 안전한 설정

    lora_alpha=16,  
    # LoRA scaling 계수 (보통 r의 1~2배, 8~128 범위 사용)
    # 값 ↑ → LoRA 영향력 증가 / 과적합 가능성 ↑
    # 값 ↓ → LoRA 반영 약함
    # r=8 기준 16은 일반적인 안정 설정

    target_modules=["q_proj", "v_proj"],  
    # 적용 레이어 선택
    # 범위: q_proj, k_proj, v_proj, o_proj 등 가능
    # 많이 적용할수록 성능 ↑ 가능 / VRAM 사용량 ↑
    # GTX 1660 기준 최소 적용(q,v) 추천

    lora_dropout=0.05,  
    # 0.0 ~ 0.3 사용
    # 값 ↑ → 과적합 방지 / 학습 속도 ↓ 가능
    # 값 ↓ → 빠른 학습 / 과적합 위험 ↑
    # 0.05는 소규모 데이터 기준 무난

    bias="none",  
    # "none", "all", "lora_only" 가능
    # none → VRAM 절약 (권장)
    # all → 성능 ↑ 가능 / 메모리 ↑

    task_type="CAUSAL_LM"
)

model = get_peft_model(model, lora_config)

# 5️⃣ JSONL 데이터셋 로드
dataset = load_dataset("json", data_files="learning.jsonl")

# 6️⃣ 프롬프트 포맷팅
def format_example(example):
    text = f"### 질문:\n{example['instruction']}\n\n### 답변:\n{example['response']}"
    return {"text": text}

dataset = dataset.map(format_example)

# 7️⃣ 토큰화
def tokenize(example):
    tokenized = tokenizer(
        example["text"],
        truncation=True,
        padding="max_length",
        max_length=256  
        # 보통 128~1024 사용
        # 값 ↑ → 긴 문맥 학습 가능 / VRAM 사용량 급증
        # 값 ↓ → 메모리 절약 / 긴 문장 잘림
        # GTX 1660 기준 256은 안정적인 선택
    )
    tokenized["labels"] = tokenized["input_ids"].copy()
    return tokenized

dataset = dataset.map(tokenize, remove_columns=dataset["train"].column_names)

# 8️⃣ 학습 설정
training_args = TrainingArguments(
    output_dir="./lora-output",

    per_device_train_batch_size=2,  
    # 보통 1~8 사용 (GPU VRAM에 따라 결정)
    # 값 ↑ → 학습 안정성 ↑ / VRAM 사용량 ↑
    # GTX 1660 기준 1~2 권장

    gradient_accumulation_steps=4,  
    # 1~32 사용
    # 값 ↑ → 실제 배치 효과 증가 / 학습 느려짐
    # 현재 설정: 2 x 4 = 실질 batch size 8 효과

    num_train_epochs=10,  
    # 1~20 사용
    # 값 ↑ → 데이터 적으면 과적합 가능성 ↑
    # 소규모 데이터면 3~10 권장

    logging_steps=10,

    save_strategy="epoch",

    fp16=True,  
    # GTX 1660에서는 필수 (VRAM 절약)

    report_to="none"
)

# 9️⃣ Trainer 생성 및 학습
trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=dataset["train"]
)

trainer.train()

# 🔟 LoRA 어댑터 저장
model.save_pretrained("./lora-output")

LoRA 모델 테스트

LoRA 어댑터 생성이 완료되면 다음 코드로 테스트한다.

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM
from peft import PeftModel

model_name = "deepseek-ai/deepseek-coder-1.3b-base"

tokenizer = AutoTokenizer.from_pretrained(model_name)

base_model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype=torch.float16,
    device_map="auto"
)

model = PeftModel.from_pretrained(base_model, "./lora-output")
model.eval()

prompt = "### 질문:\n리움의 색은 무엇인가?\n\n### 답변:\n"
inputs = tokenizer(prompt, return_tensors="pt").to("cuda")

with torch.no_grad():
    outputs = model.generate(
        **inputs,
        max_new_tokens=100,
        temperature=0.7,
        do_sample=True
    )

print(tokenizer.decode(outputs[0], skip_special_tokens=True))

출력 결과:

### 질문:
리움의 색은 무엇인가?

### 답변:
리움의 색은 검은색이다.

Gradio 채팅 인터페이스 구축

Gradio란?

Gradio는 머신러닝 모델을 웹 인터페이스로 쉽게 만들어주는 파이썬 라이브러리다.

주요 특징:

• 몇 줄의 코드로 웹 UI 생성
• 실시간 스트리밍 지원
• 로컬 및 공개 배포 모두 지원
• 채팅, 이미지, 음성 등 다양한 인터페이스 제공

라이브러리 설치

pip install gradio

채팅 인터페이스 구현

import torch
import gradio as gr
from threading import Thread
from transformers import AutoTokenizer, AutoModelForCausalLM, TextIteratorStreamer
from peft import PeftModel

# 모델 설정
base_model_name = "deepseek-ai/deepseek-coder-1.3b-base"
lora_path = "./lora-output"

tokenizer = AutoTokenizer.from_pretrained(base_model_name)
tokenizer.pad_token = tokenizer.eos_token

base_model = AutoModelForCausalLM.from_pretrained(
    base_model_name,
    torch_dtype=torch.float16,
    device_map="auto"
)

model = PeftModel.from_pretrained(base_model, lora_path)
model.eval()

def chat_stream(message, history):
    conversation = ""

    # 대화 히스토리를 학습 시 사용한 프롬프트 형식으로 변환
    for item in history:
        if item["role"] == "user":
            conversation += f"### 질문:\n{item['content']}\n\n"
        elif item["role"] == "assistant":
            conversation += f"### 답변:\n{item['content']}\n\n"

    conversation += f"### 질문:\n{message}\n\n### 답변:\n"

    inputs = tokenizer(conversation, return_tensors="pt").to(model.device)

    # 실시간 스트리밍을 위한 TextIteratorStreamer 생성
    streamer = TextIteratorStreamer(
        tokenizer,
        skip_prompt=True,
        skip_special_tokens=True
    )

    generation_kwargs = dict(
        **inputs,
        max_new_tokens=200,
        temperature=0.3,
        top_p=0.8,
        repetition_penalty=1.1,
        do_sample=True,
        streamer=streamer
    )

    # 별도 스레드에서 생성 시작
    thread = Thread(target=model.generate, kwargs=generation_kwargs)
    thread.start()

    # 실시간으로 생성된 텍스트를 yield
    partial_text = ""
    for new_text in streamer:
        partial_text += new_text
        yield partial_text

demo = gr.ChatInterface(
    fn=chat_stream,
    title="DeepSeek Chat"
)

if __name__ == "__main__":
    demo.launch()

주요 코드 설명

1. 대화 히스토리 처리

Gradio의 ChatInterface는 대화를 다음 형식으로 전달한다:

[
    {"role": "user", "content": "안녕?"},
    {"role": "assistant", "content": "안녕하세요!"},
]

이를 학습 시 사용한 프롬프트 형식(### 질문: / ### 답변:)으로 변환한다.

2. 실시간 스트리밍

streamer = TextIteratorStreamer(tokenizer, skip_prompt=True, skip_special_tokens=True)
thread = Thread(target=model.generate, kwargs=generation_kwargs)
thread.start()

for new_text in streamer:
    partial_text += new_text
    yield partial_text

• TextIteratorStreamer: 생성된 토큰을 실시간으로 반환
• Thread: 별도 스레드에서 생성 (메인 스레드 블로킹 방지)
• yield: 생성된 텍스트를 즉시 화면에 표시

3. 생성 파라미터

실행 결과

터미널에 다음과 같이 표시된다:

Running on local URL:  http://127.0.0.1:7860

브라우저에서 해당 주소로 접속하면 채팅 인터페이스를 사용할 수 있다.

외부에서 접속 가능한 임시 URL을 생성하려면:

demo.launch(share=True)

생성 붕괴 현상 및 해결

문제 상황

인사 이후 짧은 대화를 이어가려 했지만 이상한 답변을 받았다.

붕괴 현상이란?

소형 모델에서 자주 발생하는 생성 붕괴(Generation Collapse) 또는 문맥 이탈(Context Drift) 현상이다. 대화가 길어지거나 복잡해질수록 모델이 문맥을 유지하지 못하고 의미 없는 텍스트를 반복하거나 엉뚱한 답변을 생성한다.

붕괴 증상

1. 문맥 붕괴: 이전 대화 내용을 무시하고 엉뚱한 답변
2. 의미 단절: 문장이 중간에 끊기거나 의미가 연결되지 않음
3. 토큰 반복: 같은 단어나 문장을 무한 반복
4. 문맥 이탈: 질문과 전혀 관계없는 내용 생성

원인 분석

현재 테스트는 1.3B 초소형 모델을 사용했다.

모델 크기별 붕괴 빈도

해결 방안

1. 더 큰 모델 사용 (권장)

7B 모델: 일반 사용자용 최소 권장 크기

• deepseek-coder-7b-base
• 대부분의 대화에서 안정적 동작

13B+ 모델: 전문적 용도

• 복잡한 논리 추론 필요 시
• VRAM 16GB 이상 권장

2. 대화 길이 제한

최근 N개 턴만 컨텍스트로 사용:

def chat_stream(message, history):
    # 최근 5턴(10개 메시지)만 유지
    recent_history = history[-10:] if len(history) > 10 else history
    # ...

3. 생성 파라미터 조정

붕괴를 줄이는 파라미터 설정:

generation_kwargs = dict(
    **inputs,
    max_new_tokens=150,           # 생성 길이 줄임
    temperature=0.5,              # 온도 높임
    top_p=0.9,                    # nucleus sampling 강화
    repetition_penalty=1.3,       # 반복 억제 강화
    no_repeat_ngram_size=3,       # 3-gram 반복 금지
    do_sample=True,
    streamer=streamer
)

4. 프롬프트 엔지니어링

시스템 프롬프트 추가:

def chat_stream(message, history):
    conversation = "### 시스템:\n간결하고 정확하게 답변하세요. 같은 내용을 반복하지 마세요.\n\n"
    # ...

마치며

이번 가이드에서는 로컬 환경에서 DeepSeek 모델을 세팅하고, LoRA Fine-tuning을 통해 커스터마이징한 뒤, Gradio로 실용적인 채팅 인터페이스를 구축하는 전 과정을 다뤘다.

핵심 요약:

• 1.3B 모델: 학습 및 테스트용으로 적합, 실제 서비스에는 부적합
• 실용적 권장: 최소 7B 모델 사용, 대화 길이 제한 (5~10턴), 생성 파라미터 최적화
• LoRA의 장점: VRAM 절약, 빠른 학습, 여러 어댑터 병행 가능

로컬 LLM은 데이터 보안과 커스터마이징이 중요한 환경에서 매우 유용한 선택지가 될 수 있다.

1. OpenSSL 세팅
2. OpenSSL을 통한 개인키/공개키 생성
3. 개인키/공개키를 활용한 암복호화

OpenSSL 세팅

SSL이란?

SSL(Secure Socket Layer)이란? SSL이란 보안 소켓 계층을 이르는 것으로, 인터넷 상에서 데이터를 안전하게 전송하기 위한 인터넷 암호화 통신 프로토콜이며 데이터 보안을 위해서 개발한 통신 레이어다.

OpenSSL이란?

웹브라우저와 서버 간의 통신을 암호화하는 오픈소스 라이브러리라고 보면 된다. 한 마디로 Openssl을 웹서버(Apache,Nginx)에서 자유롭게 사용할 수 있다. Openssl 사용현황은 대부분의 사이트가 2/3가 Openssl을 채용했다고 보면된다.

보안이슈

Heart bleed bug 구버전에서 발생된 현상으로 보안을 위해 보안이슈과 최신버전을 수시로 확인해야 할 것 같다.

세팅

설치 프로그램 파일 다운로드 URL : http://slproweb.com/products/Win32OpenSSL.html (환경에 맞게 설치)

(해당 글에서는 Win64 OpenSSL v1.1.1s EXE를 받았음)

CMD 실행 > openssl 커맨드 입력

OpenSSL을 통한 개인키공개키 생성

공개키 방식이란?

우선 공개키, 비공개 키의 등장 배경인 대칭키 방식에 대하여 간단히 정리하자면 동일한 키로 암호화, 복호화를 동시에 진행할 수 있는 방식이다. 예르들어 'abcd'라는 키로 암호화를 하면, 복호화 시에 'abcd'를 입력해야 한다. 위 과정에서는 대칭키 전달 과정에서 누군가가 대칭키를 획득한다면 쉽게 암호화된 데이터를 알아낼 수 있다.

위와 같은 단점을 보완하기 위한 것이 공개키 방식이다.

공개키 방식에서는 두 개의 키를 갖는다. 누구에가나 공개가 가능한 공개키(Public Key), 자신만이 갖고 있는 개인키(Private Key) 이 공개키 알고리즘은 공개키로 암호화를 하냐, 개인키로 암호화를 하냐에 따라 사용분야가 달라진다.

공개키로 암호화를 하는것은 데이터 보안에 중점을 두는것이고, 개인키로 암호화를 하면 인증 과정에 중점을 두는 것이다.

이해 하기 쉬운 설명 : https://brunch.co.kr/@artiveloper/24

개인키(Pirvate Key) 생성

CMD 실행 후 순차적으로 커맨드 실행
openssl > genrsa -out private_key.pem 1024

공개키(Public Key) 생성

위에서 생성한 개인키를 활용하여 키쌍을 생성한다.

CMD 실행 후 순차적으로 커맨드 실행
openssl > rsa -in private_key.pem -out public_key.pem -pubout

키 파일 확인

USER 디렉터리에 물리파일이 생성된걸 확인할 수 있음.

개인키공개키를 활용한 암복호화

RSA 알고리즘을 사용하였으며, RSA 알고리즘은 공개키 암호 알고리즘 중의 하나이며, 세계적으로 사용하는 표준적인 알고리즘이다.

package org.qrcode.controller;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.crypto.Cipher;
import javax.inject.Inject;
import javax.servlet.ServletContext;
import javax.xml.bind.DatatypeConverter;
import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.security.KeyFactory;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.Base64;


@RestController
public class qhdksController {

    @Inject
    private ServletContext context;

    @RequestMapping(value = "/test.do")
    public String test() throws Exception {

        String secretText = "비밀이야"; // 암·복호화를 할 텍스트

        String secretTextEncryption = encryption(secretText); // 암호화

        String decryption = decryption(secretTextEncryption); // 복호화 

        return decryption;
    }

    // 암호화 메서드
    private String encryption(String secretText) {
        byte[] secretTextBytes = secretText.getBytes();

        String fullPath = context.getRealPath("/WEB-INF/classes/message/public_key.pem");

        String key = null;

        BufferedInputStream bs = null;
        try {
            bs = new BufferedInputStream(new FileInputStream(fullPath));
            byte[] b = new byte[bs.available()];
            while (bs.read(b) != -1) {
            }

            key = new String(b);
        } catch (Exception e) {
        } finally {
            try {
                bs.close();
            } catch (Exception e) {
                return "key읽기실패";
            }
        }

        String publicKeyPEM = key.replace("-----BEGIN PUBLIC KEY-----", "")
                .replaceAll("\n", "").replace("-----END PUBLIC KEY-----", "");

        byte[] a = DatatypeConverter.parseBase64Binary(publicKeyPEM);
        String encryptedData = null;
        try {
            //평문으로 전달받은 공개키를 공개키객체로 만드는 과정
            KeyFactory keyFactory = KeyFactory.getInstance("RSA");
            X509EncodedKeySpec publicKeySpec = new X509EncodedKeySpec(a);
            PublicKey publicKey = keyFactory.generatePublic(publicKeySpec);

            //만들어진 공개키객체를 기반으로 암호화모드로 설정하는 과정
            Cipher cipher = Cipher.getInstance("RSA");
            cipher.init(Cipher.ENCRYPT_MODE, publicKey);

            //평문을 암호화하는 과정
            byte[] byteEncryptedData = cipher.doFinal(secretText.getBytes());
            encryptedData = Base64.getEncoder().encodeToString(byteEncryptedData);

        } catch (Exception e) {
            System.out.println("암호화 실패");
        }

        return encryptedData;
    }

    // 복호화 메서드
    private String decryption(String encryptedText) throws Exception {
        String decryptedText = null;

        String fullPath = context.getRealPath("/WEB-INF/classes/message/private_key.pem");

        String key = null;

        BufferedInputStream bs = null;
        try {
            bs = new BufferedInputStream(new FileInputStream(fullPath));
            byte[] b = new byte[bs.available()];
            while (bs.read(b) != -1) {
            }

            key = new String(b);
        } catch (Exception e) {
        } finally {
            try {
                bs.close();
            } catch (Exception e) {
                return "key읽기실패";
            }
        }

        String privateKeyPEM = key.replace("-----BEGIN PRIVATE KEY-----", "")
                .replaceAll("\n", "").replace("-----END PRIVATE KEY-----", "");

        byte[] a = DatatypeConverter.parseBase64Binary(privateKeyPEM);

        try {
            //평문으로 전달받은 개인키를 개인키객체로 만드는 과정
            KeyFactory keyFactory = KeyFactory.getInstance("RSA");
            PKCS8EncodedKeySpec privateKeySpec = new PKCS8EncodedKeySpec(a);
            PrivateKey privateKey = keyFactory.generatePrivate(privateKeySpec);

            //만들어진 개인키객체를 기반으로 암호화모드로 설정하는 과정
            Cipher cipher = Cipher.getInstance("RSA");
            cipher.init(Cipher.DECRYPT_MODE, privateKey);

            //암호문을 평문화하는 과정
            byte[] byteEncryptedData = Base64.getDecoder().decode(encryptedText.getBytes());
            byte[] byteDecryptedData = cipher.doFinal(byteEncryptedData);
            decryptedText = new String(byteDecryptedData);
        } catch (Exception e) {
            System.out.println("복호화 실패");
        }

        return decryptedText;
    }
}

kf.generatePublic(keySpec) 코드에서 에러가 발생하는 경우

 HTTP Status 500 - Request processing failed; nested exception is java.security.spec.InvalidKeySpecException: java.security.InvalidKeyException: invalid key format

원인은 자바에서 지원하는 RSA PEM 파일 형식이 맞지 않기 때문이다. 자바는 PKCS#1을 지원하지 않고, PKCS#8만 지원한다.

-----BEGIN RSA PRIVATE KEY-----

.

.

.

-----END RSA PRIVATE KEY-----

-----BEGIN PRIVATE KEY-----

.

.

.

-----END PRIVATE KEY-----

자바에서 사용하는 경우 pkcs#8 형식으로 변환 혹은 재생성을 하도록 한다.