diff --git a/WebContent/addon/summernote/summernote-custom.js b/WebContent/addon/summernote/summernote-custom.js
index 5682528..dd3ab5c 100644
--- a/WebContent/addon/summernote/summernote-custom.js
+++ b/WebContent/addon/summernote/summernote-custom.js
@@ -32,13 +32,18 @@ function addImageUploadGuide($modal) {
 
 /**
  * Summernote 에디터 공통 초기화 함수
- * - 이미지 붙여넣기 시 data-uri(Base64) 방식으로 처리
+ * - 기본: data-uri(Base64) 방식으로 이미지 처리
+ * - useFileUpload: true 옵션 시 서버 업로드 방식 사용
  * - 이미지 리사이징 지원
  * @param {string} selector - 에디터 selector (예: '#contents')
- * @param {object} customOptions - 추가 옵션 (선택사항)
+ * @param {object} customOptions - 추가 옵션
+ *   - useFileUpload: true면 서버 업로드 방식, false면 data-uri 방식 (기본값: false)
+ *   - uploadUrl: 이미지 업로드 API URL (useFileUpload: true 시 필수)
+ *   - imageViewUrl: 이미지 서빙 API URL (useFileUpload: true 시 필수)
  */
 function initSummernote(selector, customOptions) {
     customOptions = customOptions || {};
+    var useFileUpload = customOptions.useFileUpload || false;
 
     // 기본 설정
     var defaultOptions = {
@@ -73,57 +78,102 @@ function initSummernote(selector, customOptions) {
                     }
                 });
 
+                // 이미지 스타일 변경 감지 - text-align을 올바른 CSS로 변환
+                var observer = new MutationObserver(function(mutations) {
+                    mutations.forEach(function(mutation) {
+                        if (mutation.type === 'attributes' && mutation.attributeName === 'style') {
+                            var $img = $(mutation.target);
+                            if ($img.is('img')) {
+                                var style = $img.attr('style') || '';
+                                // text-align: center -> display: block; margin: auto
+                                if (style.indexOf('text-align: center') !== -1 || style.indexOf('text-align:center') !== -1) {
+                                    $img.css({
+                                        'text-align': '',
+                                        'display': 'block',
+                                        'margin-left': 'auto',
+                                        'margin-right': 'auto',
+                                        'float': 'none'
+                                    });
+                                }
+                                // text-align: left -> float: left
+                                else if (style.indexOf('text-align: left') !== -1 || style.indexOf('text-align:left') !== -1) {
+                                    $img.css({
+                                        'text-align': '',
+                                        'display': '',
+                                        'margin-left': '',
+                                        'margin-right': '',
+                                        'float': 'left'
+                                    });
+                                }
+                                // text-align: right -> float: right
+                                else if (style.indexOf('text-align: right') !== -1 || style.indexOf('text-align:right') !== -1) {
+                                    $img.css({
+                                        'text-align': '',
+                                        'display': '',
+                                        'margin-left': '',
+                                        'margin-right': '',
+                                        'float': 'right'
+                                    });
+                                }
+                            }
+                        }
+                    });
+                });
+                observer.observe($editable[0], {
+                    attributes: true,
+                    subtree: true,
+                    attributeFilter: ['style']
+                });
+
                 // 커스텀 onInit 콜백 호출
                 if (customOptions.callbacks && customOptions.callbacks.onInit) {
                     customOptions.callbacks.onInit.call(this);
                 }
             },
-            // 이미지 업로드 처리 - data-uri(Base64) 방식
+            // 이미지 업로드 처리
             onImageUpload: function(files) {
                 for (var i = 0; i < files.length; i++) {
-                    insertImageAsDataUri(files[i], $(selector));
-                }
-            },
-            // 붙여넣기 시 이미지 처리 (MS Office 등에서 복사한 이미지 포함)
-            onPaste: function(e) {
-                var clipboardData = e.originalEvent.clipboardData;
-                if (!clipboardData || !clipboardData.items) return;
-
-                var items = clipboardData.items;
-                var imageFile = null;
-
-                // 1. 먼저 순수 이미지 파일이 있는지 확인
-                for (var i = 0; i < items.length; i++) {
-                    if (items[i].type.indexOf('image') !== -1) {
-                        imageFile = items[i].getAsFile();
-                        break;
+                    if (useFileUpload) {
+                        // 서버 업로드 방식
+                        uploadImageToServer(files[i], $(selector), customOptions);
+                    } else {
+                        // data-uri 방식 (기본)
+                        insertImageAsDataUri(files[i], $(selector));
                     }
                 }
+            },
+            // 붙여넣기 시 선택 영역 삭제 처리
+            onPaste: function(e) {
+                var clipboardData = e.originalEvent.clipboardData;
+                if (!clipboardData) return;
 
-                // 2. 이미지 파일이 있으면 data-uri로 변환하여 삽입
-                if (imageFile) {
-                    e.preventDefault();
-                    e.stopPropagation();
-                    insertImageAsDataUri(imageFile, $(selector));
-                    return;
+                // 현재 선택 영역이 있으면 삭제 (전체 선택 후 붙여넣기 대응)
+                var selection = window.getSelection();
+                if (selection && !selection.isCollapsed) {
+                    // 선택 영역 삭제
+                    selection.deleteFromDocument();
                 }
 
-                // 3. HTML 붙여넣기인 경우 (MS Office 등) - 이미지 태그 정리
-                var htmlData = clipboardData.getData('text/html');
-                if (htmlData && htmlData.indexOf('<img') !== -1) {
-                    e.preventDefault();
-                    e.stopPropagation();
-
-                    // HTML에서 이미지 src 추출 및 정리
-                    var cleanedHtml = cleanPastedHtml(htmlData);
-
-                    // 에디터에 포커스 후 HTML 삽입
-                    $(selector).summernote('focus');
-                    setTimeout(function() {
-                        $(selector).summernote('pasteHTML', cleanedHtml);
-                    }, 10);
-                    return;
+                // 이미지 파일이 있는지 확인
+                var items = clipboardData.items;
+                if (items) {
+                    for (var i = 0; i < items.length; i++) {
+                        if (items[i].type.indexOf('image') !== -1) {
+                            var imageFile = items[i].getAsFile();
+                            if (imageFile) {
+                                e.preventDefault();
+                                e.stopPropagation();
+                                if (useFileUpload) {
+                                    uploadImageToServer(imageFile, $(selector), customOptions);
+                                } else {
+                                    insertImageAsDataUri(imageFile, $(selector));
+                                }
+                                return;
+                            }
+                        }
+                    }
                 }
+                // 이미지가 아닌 경우 summernote 기본 동작
             },
             // 다이얼로그 열릴 때 - 이미지 다이얼로그 안내 문구 추가
             onDialogShown: function() {
@@ -138,6 +188,17 @@ function initSummernote(selector, customOptions) {
                 if ($openModal.find('.note-image-dialog').length || $openModal.find('[class*="image"]').length) {
                     addImageUploadGuide($openModal);
                 }
+            },
+            // 이미지 삭제 시 서버 파일도 삭제 (컨텍스트 메뉴 "사진 삭제" 클릭 시)
+            onMediaDelete: function(target) {
+                if (useFileUpload) {
+                    var $img = $(target);
+                    var fileId = $img.attr('data-file-id');
+                    if (fileId) {
+                        // 서버에 파일 삭제 요청
+                        deleteImageFromServer(fileId, customOptions);
+                    }
+                }
             }
         }
     };
@@ -245,3 +306,225 @@ function cleanPastedHtml(html) {
 
     return cleanedHtml;
 }
+
+/**
+ * 이미지를 서버에 업로드하고 플레이스홀더로 에디터에 삽입
+ * @param {File} file - 이미지 파일
+ * @param {jQuery} $editor - summernote 에디터 jQuery 객체
+ * @param {object} options - 업로드 옵션 (uploadUrl, imageViewUrl 필수)
+ */
+function uploadImageToServer(file, $editor, options) {
+    // 파일 크기 제한 (10MB)
+    var maxSize = 10 * 1024 * 1024;
+    if (file.size > maxSize) {
+        alert('이미지 크기는 10MB를 초과할 수 없습니다.');
+        return;
+    }
+
+    // 이미지 타입 확인
+    if (!file.type.match(/image\/(jpeg|jpg|png|gif|bmp|webp)/i)) {
+        alert('지원하지 않는 이미지 형식입니다. (jpeg, png, gif, bmp, webp만 지원)');
+        return;
+    }
+
+    var formData = new FormData();
+    formData.append('file', file);
+    formData.append('cmd', 'UPLOAD');  // 필터 인증 통과용
+
+    // 업로드 중 표시
+    var $editable = $editor.next('.note-editor').find('.note-editable');
+    var $loading = $('<div class="image-upload-loading">이미지 업로드 중...</div>');
+    $editable.append($loading);
+
+    $.ajax({
+        url: options.uploadUrl,
+        method: 'POST',
+        data: formData,
+        processData: false,
+        contentType: false,
+        xhrFields: { withCredentials: true },
+        success: function(response) {
+            $loading.remove();
+
+            if (response.success) {
+                // 이미지 URL 생성 (쿼리 파라미터 방식)
+                var imageUrl = options.imageViewUrl + '?fileId=' + response.fileId + '&fileSn=' + response.fileSn;
+
+                // 이미지 삽입
+                $editor.summernote('insertImage', imageUrl, function($image) {
+                    // 플레이스홀더 정보를 data 속성에 저장
+                    $image.attr('data-file-id', response.fileId);
+                    $image.attr('data-file-sn', response.fileSn);
+                    $image.attr('data-placeholder', response.placeholder);
+                    $image.css({
+                        'max-width': '100%',
+                        'height': 'auto'
+                    });
+                });
+            } else {
+                alert('이미지 업로드 실패: ' + (response.error || '알 수 없는 오류'));
+            }
+        },
+        error: function(xhr, status, error) {
+            $loading.remove();
+            console.error('이미지 업로드 오류:', error);
+            alert('이미지 업로드 중 오류가 발생했습니다.');
+        }
+    });
+}
+
+/**
+ * 에디터 내용에서 이미지 태그를 플레이스홀더로 변환 (저장 시 호출)
+ * @param {string} contents - HTML 내용
+ * @returns {string} 플레이스홀더로 변환된 내용
+ */
+function convertImagesToPlaceholders(contents) {
+    if (!contents) return contents;
+
+    var $temp = $('<div>').html(contents);
+
+    $temp.find('img[data-file-id]').each(function() {
+        var $img = $(this);
+        var fileId = $img.attr('data-file-id');
+        var fileSn = $img.attr('data-file-sn') || '1';
+
+        // 이미지 속성 수집
+        var attrs = [];
+        var width = $img.attr('width');
+        var height = $img.attr('height');
+        var style = $img.attr('style');
+
+        // width/height가 유효한 값일 때만 저장 (0, auto, 빈값 제외)
+        if (width && width !== 'auto' && width !== '0' && parseInt(width) > 0) {
+            attrs.push('width=' + String(width).replace('px', ''));
+        }
+        if (height && height !== 'auto' && height !== '0' && parseInt(height) > 0) {
+            attrs.push('height=' + String(height).replace('px', ''));
+        }
+        if (style && style.indexOf('width') === -1) {
+            // style에 width가 없는 경우만 저장 (중복 방지)
+            attrs.push('style=' + style);
+        }
+
+        // 플레이스홀더 생성
+        var placeholder = '{{IMG:' + fileId + ':' + fileSn;
+        if (attrs.length > 0) {
+            placeholder += '|' + attrs.join('|');
+        }
+        placeholder += '}}';
+
+        // 이미지 태그를 플레이스홀더로 교체
+        $img.replaceWith(placeholder);
+    });
+
+    return $temp.html();
+}
+
+/**
+ * 플레이스홀더를 이미지 태그로 변환 (불러올 때 호출)
+ * @param {string} contents - 플레이스홀더가 포함된 내용
+ * @param {string} baseImageUrl - 이미지 서빙 베이스 URL (예: /onl/apim/editor/image/view/)
+ * @returns {string} 이미지 태그로 변환된 HTML
+ */
+function convertPlaceholdersToImages(contents, baseImageUrl) {
+    if (!contents) return contents;
+
+    // 플레이스홀더 패턴: {{IMG:fileId:fileSn}} 또는 {{IMG:fileId:fileSn|속성}}
+    var pattern = /\{\{IMG:([a-f0-9\-]+):(\d+)(\|[^}]+)?\}\}/gi;
+
+    return contents.replace(pattern, function(match, fileId, fileSn, attrsStr) {
+        var imgTag = '<img src="' + baseImageUrl + '?fileId=' + fileId + '&fileSn=' + fileSn + '"';
+        imgTag += ' data-file-id="' + fileId + '"';
+        imgTag += ' data-file-sn="' + fileSn + '"';
+        imgTag += ' data-placeholder="' + match + '"';
+
+        // 속성 파싱
+        var hasStyle = false;
+        if (attrsStr) {
+            var parts = attrsStr.substring(1).split('|'); // 앞의 | 제거 후 분리
+            for (var i = 0; i < parts.length; i++) {
+                var kv = parts[i].split('=');
+                if (kv.length >= 2) {
+                    var key = kv[0];
+                    var value = kv.slice(1).join('='); // = 가 포함된 값 처리
+                    imgTag += ' ' + key + '="' + value + '"';
+                    if (key === 'style') hasStyle = true;
+                }
+            }
+        }
+
+        // 기본 스타일 추가
+        if (!hasStyle) {
+            imgTag += ' style="max-width:100%;height:auto;"';
+        }
+
+        imgTag += ' />';
+        return imgTag;
+    });
+}
+
+/**
+ * 서버에서 이미지 파일 삭제
+ * @param {string} fileId - 삭제할 파일 ID
+ * @param {object} options - 옵션 (uploadUrl에서 delete URL 유추)
+ */
+function deleteImageFromServer(fileId, options) {
+    if (!fileId || !options.uploadUrl) return;
+
+    // uploadUrl에서 delete URL 유추: /upload.json -> /delete.json
+    var deleteUrl = options.uploadUrl.replace('/upload.json', '/delete.json');
+
+    $.ajax({
+        url: deleteUrl,
+        method: 'POST',
+        data: {
+            cmd: 'DELETE',
+            fileId: fileId
+        },
+        success: function(response) {
+            if (response.success) {
+                console.log('이미지 삭제 완료: ' + fileId);
+            } else {
+                console.warn('이미지 삭제 실패: ' + (response.error || ''));
+            }
+        },
+        error: function(xhr, status, error) {
+            console.error('이미지 삭제 오류:', error);
+        }
+    });
+}
+
+/**
+ * 내용에서 파일 ID 목록 추출 (cleanup용)
+ * @param {string} contents - HTML 또는 플레이스홀더가 포함된 내용
+ * @returns {Array} 파일 ID 배열
+ */
+function extractFileIdsFromContent(contents) {
+    if (!contents) return [];
+
+    var fileIds = [];
+    var seen = {};
+
+    // 플레이스홀더에서 추출
+    var placeholderPattern = /\{\{IMG:([a-f0-9\-]+):\d+(\|[^}]+)?\}\}/gi;
+    var match;
+    while ((match = placeholderPattern.exec(contents)) !== null) {
+        var fileId = match[1];
+        if (!seen[fileId]) {
+            seen[fileId] = true;
+            fileIds.push(fileId);
+        }
+    }
+
+    // img 태그의 data-file-id에서 추출
+    var $temp = $('<div>').html(contents);
+    $temp.find('img[data-file-id]').each(function() {
+        var fileId = $(this).attr('data-file-id');
+        if (fileId && !seen[fileId]) {
+            seen[fileId] = true;
+            fileIds.push(fileId);
+        }
+    });
+
+    return fileIds;
+}
diff --git a/WebContent/css/editor-content.css b/WebContent/css/editor-content.css
index c144110..67817f9 100644
--- a/WebContent/css/editor-content.css
+++ b/WebContent/css/editor-content.css
@@ -200,8 +200,9 @@
     max-width: 100% !important;
     height: auto !important;
     border-radius: 8px !important;
-    margin: 16px 0 !important;
-    display: block !important;
+    margin-top: 16px !important;
+    margin-bottom: 16px !important;
+    /* margin-left, margin-right는 인라인 스타일로 정렬 제어 */
 }
 
 /* ==========================================================================
@@ -332,3 +333,51 @@
         padding: 8px !important;
     }
 }
+
+/* ==========================================================================
+   Summernote 이미지 업로드 UI
+   ========================================================================== */
+
+/* 이미지 업로드 로딩 인디케이터 */
+.image-upload-loading {
+    position: absolute;
+    top: 50%;
+    left: 50%;
+    transform: translate(-50%, -50%);
+    background: rgba(0, 73, 180, 0.9);
+    color: #fff;
+    padding: 12px 24px;
+    border-radius: 8px;
+    font-size: 14px;
+    z-index: 1000;
+    box-shadow: 0 4px 12px rgba(0, 0, 0, 0.15);
+    animation: pulse 1.5s infinite;
+}
+
+@keyframes pulse {
+    0%, 100% { opacity: 1; }
+    50% { opacity: 0.7; }
+}
+
+/* 이미지 다이얼로그 업로드 안내 */
+.image-upload-guide {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    padding: 12px 16px;
+    background: #EFF6FF;
+    border: 1px solid #BFDBFE;
+    border-radius: 8px;
+    margin-bottom: 16px;
+    font-size: 13px;
+    color: #1E40AF;
+}
+
+.image-upload-guide .material-icons {
+    font-size: 18px;
+    color: #3B82F6;
+}
+
+.image-upload-guide strong {
+    font-weight: 600;
+}
diff --git a/WebContent/jsp/onl/apim/portalterms/portalTermsManDetail.jsp b/WebContent/jsp/onl/apim/portalterms/portalTermsManDetail.jsp
index f5f7a0c..8892a90 100644
--- a/WebContent/jsp/onl/apim/portalterms/portalTermsManDetail.jsp
+++ b/WebContent/jsp/onl/apim/portalterms/portalTermsManDetail.jsp
@@ -19,12 +19,45 @@
 	<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
 	<jsp:include page="/jsp/common/include/css.jsp"/>
 	<link rel="stylesheet" type="text/css" href="<c:url value="/css/editor-content.css"/>"/>
+	<style>
+		.file-link {
+			color: #0049b4;
+			text-decoration: none;
+		}
+		.file-link:hover {
+			text-decoration: underline;
+		}
+		.file-size {
+			color: #888;
+			font-size: 12px;
+		}
+		.btn-file-delete {
+			background: none;
+			border: none;
+			cursor: pointer;
+			color: #dc3545;
+			padding: 2px 4px;
+			margin-left: 8px;
+			vertical-align: middle;
+		}
+		.btn-file-delete:hover {
+			color: #a71d2a;
+		}
+		.btn-file-delete .material-icons {
+			font-size: 16px;
+			vertical-align: middle;
+		}
+	</style>
 	<jsp:include page="/jsp/common/include/script.jsp"/>
 	<jsp:include page="/jsp/common/include/portal.jsp"/>
 	<script language="javascript">
 		var url = '<c:url value="/onl/apim/portalterms/portalTermsMan.json" />';
 		var url_view = '<c:url value="/onl/apim/portalterms/portalTermsMan.view" />';
+		var imageUploadUrl = '<c:url value="/onl/apim/editor/image/upload.json" />';
+		var imageViewUrl = '<c:url value="/onl/apim/editor/image/view.do" />';
+		var fileDownloadUrl = '<c:url value="/file/download.do" />';
 		var isDetail = false;
+		var currentAttachedFileId = null;
 
 		function decodeHTMLEntities(text) {
 			var textArea = document.createElement('textarea');
@@ -32,6 +65,42 @@
 			return textArea.value;
 		}
 
+		function formatFileSize(bytes) {
+			if (!bytes || bytes === 0) return '0 B';
+			var k = 1024;
+			var sizes = ['B', 'KB', 'MB', 'GB'];
+			var i = Math.floor(Math.log(bytes) / Math.log(k));
+			return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
+		}
+
+		function showAttachedFile(fileId, fileName, fileSize) {
+			var downloadLink = fileDownloadUrl + '?fileId=' + fileId + '&fileSn=1';
+			var html = '<a href="' + downloadLink + '" class="file-link" title="다운로드">' +
+				'<i class="material-icons" style="vertical-align: middle; font-size: 18px;">attach_file</i> ' +
+				fileName + '</a>';
+			if (fileSize) {
+				html += ' <span class="file-size">(' + formatFileSize(fileSize) + ')</span>';
+			}
+			html += ' <button type="button" class="btn-file-delete" onclick="deleteAttachedFile()" title="삭제">' +
+				'<i class="material-icons">close</i></button>';
+			$('#attachedFileInfo').html(html).show();
+			$('#attachedFileInput').hide();
+		}
+
+		function hideAttachedFile() {
+			$('#attachedFileInfo').html('').hide();
+			$('#attachedFileInput').show();
+			$('#attachedFile').val('');
+		}
+
+		function deleteAttachedFile() {
+			if (confirm('첨부파일을 삭제하시겠습니까?')) {
+				currentAttachedFileId = null;
+				$('#deleteAttachment').val('true');
+				hideAttachedFile();
+			}
+		}
+
 		function init() {
 			$.ajax({
 				type: "POST",
@@ -73,7 +142,9 @@
 					$("#status").val(data.status);
 
 					var decodedContent = decodeHTMLEntities(data.contents);
-					$('#contents').summernote('code', decodedContent);
+					// 플레이스홀더를 이미지 태그로 변환하여 에디터에 표시
+					var htmlContent = convertPlaceholdersToImages(decodedContent, imageViewUrl);
+					$('#contents').summernote('code', htmlContent);
 
 					if (data.publishedOn) {
 						$("#publishedOnDisplay").val(gridDateFormat(data.publishedOn));
@@ -86,6 +157,14 @@
 					$("#createdDate").text(timeStampFormat(data.createdDate));
 					$("#lastModifiedDate").text(timeStampFormat(data.lastModifiedDate));
 					$("#lastModifiedByName").text(data.lastModifiedByName);
+
+					// 첨부파일 정보 표시
+					currentAttachedFileId = data.attachedFileId;
+					if (data.attachedFileId && data.attachedFileName) {
+						showAttachedFile(data.attachedFileId, data.attachedFileName, data.attachedFileSize);
+					} else {
+						hideAttachedFile();
+					}
 				},
 				error: function (e) {
 					alert(e.responseText);
@@ -127,10 +206,13 @@
 				}
 			});
 
-			// Summernote 에디터 초기화 (이미지 붙여넣기 data-uri 방식, 리사이징 지원)
+			// Summernote 에디터 초기화 (파일 업로드 방식, 리사이징 지원)
 			initSummernote('#contents', {
 				placeholder: '여기에 약관 내용을 입력하세요.',
-				height: 300
+				height: 300,
+				useFileUpload: true,
+				uploadUrl: imageUploadUrl,
+				imageViewUrl: imageViewUrl
 			});
 
 			if (agreementsType && revision) {
@@ -153,19 +235,35 @@
 
 				$("#agreementsType").prop('disabled', false);
 
-				// 일반 POST로 전송 (이미지는 서버 업로드 방식으로 URL만 저장됨)
-				var postData = {
-					cmd: isDetail ? "UPDATE" : "INSERT",
-					agreementsType: $("#agreementsType").val(),
-					revision: $("#revisionHidden").val(),
-					publishedOn: $("#publishedOn").val(),
-					contents: contents
-				};
+				// 이미지 태그를 플레이스홀더로 변환 (저장 시)
+				var contentsWithPlaceholders = convertImagesToPlaceholders(contents);
+				// 현재 사용 중인 파일 ID 목록 추출
+				var usedFileIds = extractFileIdsFromContent(contentsWithPlaceholders);
+
+				// FormData로 전송 (첨부파일 포함)
+				var formData = new FormData();
+				formData.append('cmd', isDetail ? "UPDATE" : "INSERT");
+				formData.append('agreementsType', $("#agreementsType").val());
+				formData.append('revision', $("#revisionHidden").val());
+				formData.append('publishedOn', $("#publishedOn").val());
+				formData.append('contents', contentsWithPlaceholders);
+				formData.append('usedFileIds', usedFileIds.join(','));
+
+				// 첨부파일 추가
+				var attachedFile = $('#attachedFile')[0].files[0];
+				if (attachedFile) {
+					formData.append('attachedFile', attachedFile);
+				}
+
+				// 첨부파일 삭제 플래그
+				formData.append('deleteAttachment', $('#deleteAttachment').val() || 'false');
 
 				$.ajax({
 					type: "POST",
 					url: url,
-					data: postData,
+					data: formData,
+					processData: false,
+					contentType: false,
 					success: function (json) {
 						alert("<%= localeMessage.getString("common.saveMsg") %>");
 						goNav(returnUrl);
@@ -220,8 +318,9 @@
 			<button type="button" class="cssbtn" id="btn_previous" level="R" status="DETAIL,NEW"><i class="material-icons">arrow_back</i> <%= localeMessage.getString("button.previous") %></button>
 		</div>
 		<div class="title" id="title">약관</div>
-		<form id="ajaxForm">
+		<form id="ajaxForm" enctype="multipart/form-data">
 			<input type="hidden" name="revision" id="revisionHidden">
+			<input type="hidden" id="deleteAttachment" value="false">
 			<table class="table_row" cellspacing="0">
 				<tr>
 					<th style="width:10%;"><%= getRequiredLabel("약관명") %></th>
@@ -254,6 +353,16 @@
 						<input type="hidden" id="publishedOn" name="publishedOn"/>
 					</td>
 				</tr>
+				<tr>
+					<th>첨부파일</th>
+					<td colspan="3">
+						<div id="attachedFileInfo" style="display:none; padding: 5px 0;"></div>
+						<div id="attachedFileInput">
+							<input type="file" id="attachedFile" name="attachedFile" style="width:400px;">
+							<span class="file-help" style="color:#666; font-size:12px; margin-left:10px;">약관 원본 문서를 첨부할 수 있습니다.</span>
+						</div>
+					</td>
+				</tr>
 				<tr>
 					<th><%= getRequiredLabel("약관 내용") %></th>
 					<td colspan="3">
diff --git a/src/main/java/com/eactive/eai/rms/common/interceptor/AuthorizeInterceptor.java b/src/main/java/com/eactive/eai/rms/common/interceptor/AuthorizeInterceptor.java
index 51e25f0..963652e 100644
--- a/src/main/java/com/eactive/eai/rms/common/interceptor/AuthorizeInterceptor.java
+++ b/src/main/java/com/eactive/eai/rms/common/interceptor/AuthorizeInterceptor.java
@@ -7,6 +7,7 @@ import java.util.Map;
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 
+import org.apache.commons.lang3.ClassUtils;
 import org.apache.commons.lang3.StringUtils;
 import org.springframework.web.method.HandlerMethod;
 import org.springframework.web.servlet.HandlerInterceptor;
@@ -32,6 +33,14 @@ public class AuthorizeInterceptor implements HandlerInterceptor {
 	public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
 			throws Exception {
 
+		// InterceptorSkipController 구현 컨트롤러는 권한 체크 스킵
+		if (handler instanceof HandlerMethod) {
+			Class<?> clazz = ((HandlerMethod) handler).getBeanType();
+			if (ClassUtils.isAssignable(clazz, InterceptorSkipController.class)) {
+				return true;
+			}
+		}
+
 		// 요청 URI, 사용자 ID, 서비스 타입, cmd 추출
 		String uri = request.getRequestURI();
 		String userId = SessionManager.getUserId(request);
diff --git a/src/main/java/com/eactive/eai/rms/onl/apim/portalterms/EditorImageController.java b/src/main/java/com/eactive/eai/rms/onl/apim/portalterms/EditorImageController.java
new file mode 100644
index 0000000..bc64478
--- /dev/null
+++ b/src/main/java/com/eactive/eai/rms/onl/apim/portalterms/EditorImageController.java
@@ -0,0 +1,155 @@
+package com.eactive.eai.rms.onl.apim.portalterms;
+
+import com.eactive.eai.rms.common.base.BaseAnnotationController;
+import com.eactive.eai.rms.common.interceptor.InterceptorSkipController;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.MediaType;
+import org.springframework.http.ResponseEntity;
+import org.springframework.stereotype.Controller;
+import org.springframework.web.bind.annotation.*;
+import org.springframework.web.multipart.MultipartFile;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * 에디터 이미지 컨트롤러
+ * - summernote 에디터에서 사용하는 이미지 업로드/서빙 API
+ * - InterceptorSkipController: 인터셉터의 상세 검증 우회 (필터에서 기본 로그인 체크는 수행됨)
+ */
+@Controller
+@RequestMapping("/onl/apim/editor/image")
+public class EditorImageController extends BaseAnnotationController implements InterceptorSkipController {
+
+    private final EditorImageService editorImageService;
+
+    @Autowired
+    public EditorImageController(EditorImageService editorImageService) {
+        this.editorImageService = editorImageService;
+    }
+
+    /**
+     * 이미지 업로드 API
+     * - summernote에서 이미지 선택/붙여넣기 시 호출
+     * - 즉시 DB에 저장하고 플레이스홀더 정보 반환
+     *
+     * @param file MultipartFile 이미지 파일
+     * @return { success: true, fileId: "uuid", fileSn: 1, placeholder: "{{IMG:uuid:1}}" }
+     */
+    @PostMapping("/upload.json")
+    @ResponseBody
+    public ResponseEntity<Map<String, Object>> uploadImage(@RequestParam("file") MultipartFile file) {
+        Map<String, Object> result = new HashMap<>();
+
+        try {
+            // 파일 검증
+            if (file.isEmpty()) {
+                result.put("success", false);
+                result.put("error", "파일이 비어있습니다.");
+                return ResponseEntity.badRequest().body(result);
+            }
+
+            // 이미지 타입 검증
+            String contentType = file.getContentType();
+            if (contentType == null || !contentType.startsWith("image/")) {
+                result.put("success", false);
+                result.put("error", "이미지 파일만 업로드 가능합니다.");
+                return ResponseEntity.badRequest().body(result);
+            }
+
+            // 파일 크기 검증 (10MB)
+            long maxSize = 10 * 1024 * 1024;
+            if (file.getSize() > maxSize) {
+                result.put("success", false);
+                result.put("error", "파일 크기는 10MB를 초과할 수 없습니다.");
+                return ResponseEntity.badRequest().body(result);
+            }
+
+            // 이미지 저장
+            EditorImageDTO saved = editorImageService.saveImage(file);
+
+            // 성공 응답
+            result.put("success", true);
+            result.put("fileId", saved.getFileId());
+            result.put("fileSn", saved.getFileSn());
+            result.put("placeholder", "{{IMG:" + saved.getFileId() + ":" + saved.getFileSn() + "}}");
+
+            return ResponseEntity.ok(result);
+
+        } catch (Exception e) {
+            logger.error("이미지 업로드 중 오류 발생", e);
+            result.put("success", false);
+            result.put("error", "이미지 업로드 중 오류가 발생했습니다: " + e.getMessage());
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(result);
+        }
+    }
+
+    /**
+     * 이미지 서빙 API
+     * - 브라우저에서 이미지 표시용 (관리자포탈)
+     * - 캐시 설정으로 성능 최적화
+     *
+     * @param fileId 파일 ID (PTL_FILE.FILE_ID)
+     * @param fileSn 파일 순번 (PTL_FILE_DETAIL.FILE_SN)
+     * @return 이미지 바이너리 데이터
+     */
+    @GetMapping("/view.do")
+    public ResponseEntity<byte[]> viewImage(
+            @RequestParam String fileId,
+            @RequestParam(defaultValue = "1") int fileSn) {
+        try {
+            EditorImageDTO image = editorImageService.getImage(fileId, fileSn);
+
+            if (image == null || image.getImageData() == null) {
+                return ResponseEntity.notFound().build();
+            }
+
+            HttpHeaders headers = new HttpHeaders();
+            headers.setContentType(MediaType.parseMediaType(image.getContentType()));
+            headers.setContentLength(image.getFileSize());
+            headers.setCacheControl("public, max-age=86400"); // 1일 캐시
+            headers.set("Content-Disposition", "inline");
+
+            return new ResponseEntity<>(image.getImageData(), headers, HttpStatus.OK);
+
+        } catch (Exception e) {
+            logger.error("이미지 조회 중 오류 발생: fileId=" + fileId + ", fileSn=" + fileSn, e);
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
+        }
+    }
+
+    /**
+     * 이미지 삭제 API
+     * - 에디터에서 이미지 삭제 시 호출
+     * - DB에서 파일 삭제
+     *
+     * @param fileId 파일 ID (PTL_FILE.FILE_ID)
+     * @return { success: true }
+     */
+    @PostMapping("/delete.json")
+    @ResponseBody
+    public ResponseEntity<Map<String, Object>> deleteImage(@RequestParam String fileId) {
+        Map<String, Object> result = new HashMap<>();
+
+        try {
+            if (fileId == null || fileId.isEmpty()) {
+                result.put("success", false);
+                result.put("error", "파일 ID가 필요합니다.");
+                return ResponseEntity.badRequest().body(result);
+            }
+
+            editorImageService.deleteImage(fileId);
+
+            result.put("success", true);
+            return ResponseEntity.ok(result);
+
+        } catch (Exception e) {
+            logger.error("이미지 삭제 중 오류 발생: fileId=" + fileId, e);
+            result.put("success", false);
+            result.put("error", "이미지 삭제 중 오류가 발생했습니다: " + e.getMessage());
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(result);
+        }
+    }
+}
diff --git a/src/main/java/com/eactive/eai/rms/onl/apim/portalterms/EditorImageDTO.java b/src/main/java/com/eactive/eai/rms/onl/apim/portalterms/EditorImageDTO.java
new file mode 100644
index 0000000..584e3fe
--- /dev/null
+++ b/src/main/java/com/eactive/eai/rms/onl/apim/portalterms/EditorImageDTO.java
@@ -0,0 +1,46 @@
+package com.eactive.eai.rms.onl.apim.portalterms;
+
+import lombok.Data;
+
+/**
+ * 에디터 이미지 DTO
+ * - summernote 에디터에서 업로드된 이미지 정보를 담는 DTO
+ */
+@Data
+public class EditorImageDTO {
+
+    /**
+     * 파일 ID (PTL_FILE.FILE_ID)
+     */
+    private String fileId;
+
+    /**
+     * 파일 순번 (PTL_FILE_DETAIL.FILE_SN)
+     */
+    private int fileSn;
+
+    /**
+     * 원본 파일명
+     */
+    private String originalFileName;
+
+    /**
+     * 파일 확장자
+     */
+    private String fileExtension;
+
+    /**
+     * 파일 크기 (bytes)
+     */
+    private int fileSize;
+
+    /**
+     * Content-Type (MIME 타입)
+     */
+    private String contentType;
+
+    /**
+     * 이미지 바이너리 데이터 (조회 시에만 사용)
+     */
+    private byte[] imageData;
+}
diff --git a/src/main/java/com/eactive/eai/rms/onl/apim/portalterms/EditorImageService.java b/src/main/java/com/eactive/eai/rms/onl/apim/portalterms/EditorImageService.java
new file mode 100644
index 0000000..2ffade4
--- /dev/null
+++ b/src/main/java/com/eactive/eai/rms/onl/apim/portalterms/EditorImageService.java
@@ -0,0 +1,231 @@
+package com.eactive.eai.rms.onl.apim.portalterms;
+
+import com.eactive.apim.portal.file.entity.FileDetail;
+import com.eactive.apim.portal.file.entity.FileInfo;
+import com.eactive.apim.portal.file.service.FileService;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.web.multipart.MultipartFile;
+
+import java.io.IOException;
+import java.util.HashSet;
+import java.util.Set;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * 에디터 이미지 서비스
+ * - summernote 에디터에서 사용하는 이미지 업로드/조회/삭제 서비스
+ * - FileService를 래핑하여 이미지 전용 기능 제공
+ */
+@Service
+@Transactional(transactionManager = "transactionManagerForEMS")
+@Slf4j
+public class EditorImageService {
+
+    /**
+     * 플레이스홀더 패턴: {{IMG:fileId:fileSn}} 또는 {{IMG:fileId:fileSn|속성}}
+     * - fileId: UUID 형식 (예: 550e8400-e29b-41d4-a716-446655440000)
+     * - fileSn: 정수 (예: 1)
+     * - 속성: 선택적 (예: |width=300|height=200|style=max-width:100%)
+     */
+    private static final Pattern PLACEHOLDER_PATTERN =
+            Pattern.compile("\\{\\{IMG:([a-f0-9\\-]+):(\\d+)(\\|[^}]+)?\\}\\}");
+
+    private final FileService fileService;
+
+    @Autowired
+    public EditorImageService(FileService fileService) {
+        this.fileService = fileService;
+    }
+
+    /**
+     * 이미지 저장
+     *
+     * @param file MultipartFile 이미지 파일
+     * @return EditorImageDTO (fileId, fileSn 포함)
+     * @throws IOException 파일 처리 중 오류 발생 시
+     */
+    public EditorImageDTO saveImage(MultipartFile file) throws IOException {
+        String fileName = file.getOriginalFilename();
+        String contentType = file.getContentType();
+        byte[] data = file.getBytes();
+
+        // FileService를 통해 저장
+        FileInfo fileInfo = fileService.createSingleFileFromBytes(fileName, contentType, data);
+        FileDetail detail = fileInfo.getFileDetails().get(0);
+
+        // DTO로 변환하여 반환
+        EditorImageDTO dto = new EditorImageDTO();
+        dto.setFileId(fileInfo.getFileId());
+        dto.setFileSn(detail.getFileSn());
+        dto.setOriginalFileName(detail.getOriginalFileName());
+        dto.setFileExtension(detail.getFileExtension());
+        dto.setFileSize(detail.getFileSize());
+
+        return dto;
+    }
+
+    /**
+     * 이미지 조회
+     *
+     * @param fileId 파일 ID
+     * @param fileSn 파일 순번
+     * @return EditorImageDTO (imageData 포함)
+     * @throws IOException 파일 조회 중 오류 발생 시
+     */
+    @Transactional(readOnly = true)
+    public EditorImageDTO getImage(String fileId, int fileSn) throws IOException {
+        FileDetail detail = fileService.getFileDetailByIds(fileId, fileSn);
+        byte[] data = fileService.retrieveFileContent(detail);
+
+        EditorImageDTO dto = new EditorImageDTO();
+        dto.setFileId(fileId);
+        dto.setFileSn(fileSn);
+        dto.setOriginalFileName(detail.getOriginalFileName());
+        dto.setFileExtension(detail.getFileExtension());
+        dto.setFileSize(detail.getFileSize());
+        dto.setContentType(getContentType(detail.getFileExtension()));
+        dto.setImageData(data);
+
+        return dto;
+    }
+
+    /**
+     * 본문에서 사용 중인 파일 ID 추출
+     *
+     * @param contents 본문 내용 (플레이스홀더 포함)
+     * @return 사용 중인 파일 ID Set
+     */
+    public Set<String> extractFileIds(String contents) {
+        Set<String> fileIds = new HashSet<>();
+        if (contents == null || contents.isEmpty()) {
+            return fileIds;
+        }
+
+        Matcher matcher = PLACEHOLDER_PATTERN.matcher(contents);
+        while (matcher.find()) {
+            fileIds.add(matcher.group(1)); // fileId
+        }
+        return fileIds;
+    }
+
+    /**
+     * 이미지 삭제
+     *
+     * @param fileId 삭제할 파일 ID
+     */
+    public void deleteImage(String fileId) {
+        try {
+            fileService.deleteFile(fileId);
+            log.info("Deleted image: {}", fileId);
+        } catch (Exception e) {
+            log.warn("Failed to delete image: {}", fileId, e);
+            throw e;
+        }
+    }
+
+    /**
+     * 미사용 이미지 정리
+     * - 원래 저장된 이미지 중 현재 본문에서 사용되지 않는 이미지 삭제
+     *
+     * @param usedFileIds    본문에서 사용 중인 파일 ID 목록
+     * @param originalFileIds 원래 저장된 모든 파일 ID 목록
+     */
+    public void cleanupUnusedImages(Set<String> usedFileIds, Set<String> originalFileIds) {
+        if (originalFileIds == null || originalFileIds.isEmpty()) {
+            return;
+        }
+
+        for (String fileId : originalFileIds) {
+            if (!usedFileIds.contains(fileId)) {
+                try {
+                    fileService.deleteFile(fileId);
+                    log.info("Deleted unused image: {}", fileId);
+                } catch (Exception e) {
+                    // 삭제 실패 시 로그만 남기고 계속 진행
+                    log.warn("Failed to delete unused image: {}", fileId, e);
+                }
+            }
+        }
+    }
+
+    /**
+     * 플레이스홀더를 실제 이미지 태그로 변환
+     *
+     * @param contents 본문 내용 (플레이스홀더 포함)
+     * @param baseUrl  이미지 서빙 베이스 URL (예: /onl/apim/editor/image/view/)
+     * @return 이미지 태그가 포함된 HTML
+     */
+    public String convertPlaceholdersToHtml(String contents, String baseUrl) {
+        if (contents == null || contents.isEmpty()) {
+            return contents;
+        }
+
+        StringBuffer result = new StringBuffer();
+        Matcher matcher = PLACEHOLDER_PATTERN.matcher(contents);
+
+        while (matcher.find()) {
+            String fileId = matcher.group(1);
+            String fileSn = matcher.group(2);
+            String attrs = matcher.group(3); // |width=300|height=200 형태
+
+            StringBuilder img = new StringBuilder();
+            img.append("<img src=\"").append(baseUrl).append(fileId).append("/").append(fileSn).append("\"");
+
+            // 속성 파싱 및 추가
+            if (attrs != null && !attrs.isEmpty()) {
+                String[] parts = attrs.substring(1).split("\\|"); // 앞의 | 제거 후 분리
+                for (String part : parts) {
+                    String[] kv = part.split("=", 2);
+                    if (kv.length == 2) {
+                        img.append(" ").append(kv[0]).append("=\"").append(kv[1]).append("\"");
+                    }
+                }
+            }
+
+            // 기본 스타일 (style 속성이 없으면 추가)
+            if (attrs == null || !attrs.contains("style=")) {
+                img.append(" style=\"max-width:100%;height:auto;\"");
+            }
+
+            img.append(" />");
+            matcher.appendReplacement(result, Matcher.quoteReplacement(img.toString()));
+        }
+        matcher.appendTail(result);
+
+        return result.toString();
+    }
+
+    /**
+     * 파일 확장자를 Content-Type으로 변환
+     *
+     * @param extension 파일 확장자
+     * @return MIME 타입
+     */
+    private String getContentType(String extension) {
+        if (extension == null) {
+            return "application/octet-stream";
+        }
+
+        switch (extension.toLowerCase()) {
+            case "jpg":
+            case "jpeg":
+                return "image/jpeg";
+            case "png":
+                return "image/png";
+            case "gif":
+                return "image/gif";
+            case "bmp":
+                return "image/bmp";
+            case "webp":
+                return "image/webp";
+            case "svg":
+                return "image/svg+xml";
+            default:
+                return "application/octet-stream";
+        }
+    }
+}
diff --git a/src/main/java/com/eactive/eai/rms/onl/apim/portalterms/PortalTermsManController.java b/src/main/java/com/eactive/eai/rms/onl/apim/portalterms/PortalTermsManController.java
index 143c876..2582606 100644
--- a/src/main/java/com/eactive/eai/rms/onl/apim/portalterms/PortalTermsManController.java
+++ b/src/main/java/com/eactive/eai/rms/onl/apim/portalterms/PortalTermsManController.java
@@ -13,12 +13,16 @@ import org.springframework.http.ResponseEntity;
 import org.springframework.stereotype.Controller;
 import org.springframework.web.bind.annotation.GetMapping;
 import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.multipart.MultipartFile;
 
 import java.io.IOException;
 import java.util.Arrays;
 import java.util.HashMap;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 import java.util.stream.Collectors;
 
 @Controller
@@ -72,14 +76,22 @@ public class PortalTermsManController extends BaseAnnotationController {
 	}
 
 	@PostMapping(value = "/onl/apim/portalterms/portalTermsMan.json", params = "cmd=INSERT")
-	public ResponseEntity<String> insert(PortalTermsUI portalTermsUI) throws IOException {
-		portalTermsManService.insert(portalTermsUI);
+	public ResponseEntity<String> insert(PortalTermsUI portalTermsUI,
+										 @RequestParam(value = "attachedFile", required = false) MultipartFile attachedFile) throws IOException {
+		portalTermsManService.insert(portalTermsUI, attachedFile);
 		return ResponseEntity.ok().build();
 	}
 
 	@PostMapping(value = "/onl/apim/portalterms/portalTermsMan.json", params = "cmd=UPDATE")
-	public ResponseEntity<String> update(PortalTermsUI portalTermsUI) throws IOException {
-		portalTermsManService.update(portalTermsUI);
+	public ResponseEntity<String> update(PortalTermsUI portalTermsUI, String usedFileIds,
+										 @RequestParam(value = "attachedFile", required = false) MultipartFile attachedFile,
+										 @RequestParam(value = "deleteAttachment", defaultValue = "false") boolean deleteAttachment) throws IOException {
+		// 사용 중인 파일 ID 목록 파싱
+		Set<String> usedFileIdSet = new HashSet<>();
+		if (usedFileIds != null && !usedFileIds.isEmpty()) {
+			usedFileIdSet.addAll(Arrays.asList(usedFileIds.split(",")));
+		}
+		portalTermsManService.update(portalTermsUI, usedFileIdSet, attachedFile, deleteAttachment);
 		return ResponseEntity.ok().build();
 	}
 
diff --git a/src/main/java/com/eactive/eai/rms/onl/apim/portalterms/PortalTermsManService.java b/src/main/java/com/eactive/eai/rms/onl/apim/portalterms/PortalTermsManService.java
index f75dda4..1c969ef 100644
--- a/src/main/java/com/eactive/eai/rms/onl/apim/portalterms/PortalTermsManService.java
+++ b/src/main/java/com/eactive/eai/rms/onl/apim/portalterms/PortalTermsManService.java
@@ -4,15 +4,24 @@ import com.eactive.apim.portal.agreements.entity.AgreementType;
 import com.eactive.apim.portal.agreements.entity.Agreements;
 import com.eactive.apim.portal.agreements.entity.AgreementsId;
 import com.eactive.apim.portal.agreements.service.AgreementsService;
+import com.eactive.apim.portal.file.entity.FileDetail;
+import com.eactive.apim.portal.file.entity.FileInfo;
+import com.eactive.apim.portal.file.service.FileService;
 import com.eactive.eai.rms.common.base.BaseService;
 import com.eactive.eai.rms.data.entity.man.user.UserInfoService;
 import com.eactive.eai.rms.data.entity.onl.apim.portalterms.PortalTermsService;
 import org.apache.commons.lang.StringEscapeUtils;
+import org.apache.commons.lang3.StringUtils;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.data.domain.Page;
 import org.springframework.data.domain.Pageable;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
+import org.springframework.web.multipart.MultipartFile;
+
+import java.io.IOException;
+import java.util.HashSet;
+import java.util.Set;
 
 @Service
 @Transactional(transactionManager = "transactionManagerForEMS")
@@ -21,16 +30,22 @@ public class PortalTermsManService extends BaseService {
 	private final PortalTermsUIMapper portalTermsUIMapper;
 	private final AgreementsService agreementsService;
 	private final UserInfoService userInfoService;
+	private final EditorImageService editorImageService;
+	private final FileService fileService;
 
 	@Autowired
 	public PortalTermsManService(PortalTermsService portalTermsService,
 								 PortalTermsUIMapper portalTermsUIMapper,
 								 AgreementsService agreementsService,
-								 UserInfoService userInfoService){
+								 UserInfoService userInfoService,
+								 EditorImageService editorImageService,
+								 FileService fileService){
 		this.portalTermsService = portalTermsService;
 		this.portalTermsUIMapper = portalTermsUIMapper;
 		this.agreementsService = agreementsService;
 		this.userInfoService = userInfoService;
+		this.editorImageService = editorImageService;
+		this.fileService = fileService;
 	}
 
 	private String findName(String userId) {
@@ -55,25 +70,90 @@ public class PortalTermsManService extends BaseService {
 		portalTermsUI.setCreatedByName(findName(agreements.getCreatedBy()));
 		portalTermsUI.setLastModifiedByName(findName(agreements.getLastModifiedBy()));
 		portalTermsUI.setName(agreements.getAgreementsType().getDescription());
+
+		// 첨부파일 정보 조회
+		if (StringUtils.isNotBlank(agreements.getAttachedFileId())) {
+			try {
+				FileInfo fileInfo = fileService.findById(agreements.getAttachedFileId());
+				if (fileInfo != null && !fileInfo.getFileDetails().isEmpty()) {
+					FileDetail fileDetail = fileInfo.getFileDetails().get(0);
+					portalTermsUI.setAttachedFileName(fileDetail.getOriginalFileName() + "." + fileDetail.getFileExtension());
+					portalTermsUI.setAttachedFileSize((long) fileDetail.getFileSize());
+				}
+			} catch (Exception e) {
+				// 파일 조회 실패 시 무시
+				logger.warn("첨부파일 조회 실패: {}", agreements.getAttachedFileId(), e);
+			}
+		}
+
 		return portalTermsUI;
 	}
 
-	public void insert(PortalTermsUI portalTermsUI) {
+	public void insert(PortalTermsUI portalTermsUI, MultipartFile attachedFile) throws IOException {
 		portalTermsUI.setName(AgreementType.fromCode(portalTermsUI.getAgreementsType()).getDescription());
 		portalTermsUI.setContents(StringEscapeUtils.unescapeHtml(portalTermsUI.getContents()));
 		Agreements agreements = portalTermsUIMapper.toEntity(portalTermsUI);
+
+		// 첨부파일 저장
+		if (attachedFile != null && !attachedFile.isEmpty()) {
+			FileInfo fileInfo = fileService.createOrUpdateSingleFile(null, attachedFile, attachedFile.getOriginalFilename());
+			agreements.setAttachedFileId(fileInfo.getFileId());
+		}
+
 		agreementsService.save(agreements);
 	}
 
-	public void update(PortalTermsUI portalTermsUI) {
+	public void update(PortalTermsUI portalTermsUI, Set<String> usedFileIds,
+					   MultipartFile attachedFile, boolean deleteAttachment) throws IOException {
 		Agreements agreements = agreementsService.findById(portalTermsUI.getAgreementsType(), portalTermsUI.getRevision());
+
+		// 원래 내용에서 사용 중이던 파일 ID 추출
+		Set<String> originalFileIds = editorImageService.extractFileIds(agreements.getContents());
+
+		// 내용 업데이트
 		agreements.setName(AgreementType.fromCode(portalTermsUI.getAgreementsType()).getDescription());
 		agreements.setContents(StringEscapeUtils.unescapeHtml(portalTermsUI.getContents()));
 		agreements.setPublishedOn(portalTermsUI.getPublishedOn());
+
+		// 첨부파일 처리
+		String oldAttachedFileId = agreements.getAttachedFileId();
+
+		if (deleteAttachment && StringUtils.isNotBlank(oldAttachedFileId)) {
+			// 첨부파일 삭제 요청
+			fileService.deleteFile(oldAttachedFileId);
+			agreements.setAttachedFileId(null);
+		} else if (attachedFile != null && !attachedFile.isEmpty()) {
+			// 새 첨부파일 업로드
+			FileInfo fileInfo = fileService.createOrUpdateSingleFile(
+					oldAttachedFileId, attachedFile, attachedFile.getOriginalFilename());
+			agreements.setAttachedFileId(fileInfo.getFileId());
+		}
+
 		agreementsService.save(agreements);
+
+		// 미사용 이미지 정리 (저장 후 비동기적으로 처리)
+		editorImageService.cleanupUnusedImages(usedFileIds, originalFileIds);
 	}
 
 	public void delete(String agreementsType, Integer revision) {
+		// 삭제 전 사용 중인 파일 ID 추출
+		Agreements agreements = agreementsService.findById(agreementsType, revision);
+		Set<String> fileIdsToDelete = editorImageService.extractFileIds(agreements.getContents());
+		String attachedFileId = agreements.getAttachedFileId();
+
+		// 약관 삭제
 		agreementsService.delete(agreementsType, revision);
+
+		// 관련 이미지 모두 삭제
+		editorImageService.cleanupUnusedImages(new HashSet<>(), fileIdsToDelete);
+
+		// 첨부파일 삭제
+		if (StringUtils.isNotBlank(attachedFileId)) {
+			try {
+				fileService.deleteFile(attachedFileId);
+			} catch (Exception e) {
+				logger.warn("첨부파일 삭제 실패: {}", attachedFileId, e);
+			}
+		}
 	}
 }
diff --git a/src/main/java/com/eactive/eai/rms/onl/apim/portalterms/PortalTermsUI.java b/src/main/java/com/eactive/eai/rms/onl/apim/portalterms/PortalTermsUI.java
index eced443..af0fe4f 100644
--- a/src/main/java/com/eactive/eai/rms/onl/apim/portalterms/PortalTermsUI.java
+++ b/src/main/java/com/eactive/eai/rms/onl/apim/portalterms/PortalTermsUI.java
@@ -52,4 +52,13 @@ public class PortalTermsUI {
 
 	private String searchAgreementsType;
 
+	/* 첨부파일 ID */
+	private String attachedFileId;
+
+	/* 첨부파일명 (조회용) */
+	private String attachedFileName;
+
+	/* 첨부파일 크기 (조회용) */
+	private Long attachedFileSize;
+
 }