.NET에서 Excel 파일에 암호를 보호하는 방법

이 기사는 .NET 응용 프로그램에서 Aspose.Cells LowCode Spreadsheet Locker를 사용하여 Excel 파일에 암호 보호를 추가하는 방법을 보여줍니다.

현실 세계 문제

조직은 종종 Excel 스파이더에 포함 된 민감한 정보를 보장해야합니다, 예를 들어 금융 데이터, 직원 정보, 또는 소유 알고리즘. 적절한 보호없이, 이러한 파일은 권한이없는 사용자에 의해 액세스 할 수 있습니다, 잠재적으로 데이터 침해, 정보 유출 또는 지적 재산 도둑질으로 이어집니다.

솔루션 검토

Aspose.Cells LowCode Spreadsheet Locker를 사용하면 최소 코드를 사용하여 이 도전을 효율적으로 해결할 수 있습니다.이 솔루션은 개발자와 비즈니스 분석가들이 자신의 응용 프로그램이나 작업 흐름 내에서 문서 보안 조치를 구현해야하며, 민감한 정보를 보호하는 신뢰할만한 방법을 제공하며 문서를 유지하는 기능을 유지합니다.

원칙

솔루션을 실행하기 전에, 당신이 가지고 있는지 확인하십시오 :

Visual Studio 2019 또는 이후
.NET 6.0 또는 이후 (NET Framework 4.6.2+와 호환)
NuGet을 통해 설치된 .NET 패키지에 대한 Aspose.Cells
C# 프로그래밍의 기본 이해

PM> Install-Package Aspose.Cells

단계별 실행

단계 1: 설치 및 설정 Aspose.Cells

프로젝트에 Aspose.Cells 패키지를 추가하고 필요한 이름 공간을 포함하십시오 :

using Aspose.Cells;
using Aspose.Cells.LowCode;
using System;
using System.IO;

단계 2: 입력 데이터를 준비하십시오

보호가 필요한 Excel 파일을 식별하고 응용 프로그램에서 접근할 수 있는지 확인하십시오.

// Define the path to your Excel file
string inputFilePath = "mytemplate.xlsx";

// Verify the file exists before processing
if (!File.Exists(inputFilePath))
{
    Console.WriteLine($"Error: Input file {inputFilePath} not found.");
    return;
}

3단계 : Spreadsheet Locker 옵션을 설정합니다.

당신의 보안 요구 사항에 따라 Spreadsheet Locker 프로세스에 대한 옵션을 설정하십시오 :

// Configure loading options
LowCodeLoadOptions loadOptions = new LowCodeLoadOptions
{
    InputFile = inputFilePath
};

// Configure saving options
LowCodeSaveOptions saveOptions = new LowCodeSaveOptions
{
    SaveFormat = SaveFormat.Xlsx,
    OutputFile = "protected_spreadsheet.xlsx" // Optional if using stream output
};

단계 4: Spreadsheet Locker 프로세스를 실행

구성된 옵션으로 보호 작업을 실행하십시오 :

// Define the password for file encryption
string password = "SecurePassword123";

// Execute the process
SpreadsheetLocker.Process(loadOptions, saveOptions, password, null);

Console.WriteLine("File has been successfully protected with a password.");

5단계: 출력 처리

보호를 확인하고 사용자에게 안전한 파일에 대한 피드백을 제공하십시오 :

// Verify file was created successfully
if (File.Exists(saveOptions.OutputFile))
{
    Console.WriteLine($"Protected file created at: {saveOptions.OutputFile}");
    
    // Optionally attempt to verify the protection
    try
    {
        // This will throw an exception if the file is properly protected
        new Workbook(saveOptions.OutputFile);
        Console.WriteLine("Warning: File may not be properly protected!");
    }
    catch (CellsException ex)
    {
        if (ex.Code == ExceptionType.IncorrectPassword)
        {
            Console.WriteLine("Verification successful: File is password protected.");
        }
        else
        {
            Console.WriteLine($"Unexpected error during verification: {ex.Message}");
        }
    }
}

단계 6 : 실수 처리 실행

강력한 작동을 보장하기 위해 적절한 오류 처리를 추가하십시오 :

try
{
    // Configure options
    LowCodeLoadOptions loadOptions = new LowCodeLoadOptions
    {
        InputFile = inputFilePath
    };
    
    LowCodeSaveOptions saveOptions = new LowCodeSaveOptions
    {
        SaveFormat = SaveFormat.Xlsx,
        OutputFile = "protected_spreadsheet.xlsx"
    };
    
    // Execute protection process
    SpreadsheetLocker.Process(loadOptions, saveOptions, password, null);
    Console.WriteLine("Password protection applied successfully.");
}
catch (CellsException ex)
{
    Console.WriteLine($"Aspose.Cells error: {ex.Message}");
    Console.WriteLine($"Error code: {ex.Code}");
}
catch (IOException ex)
{
    Console.WriteLine($"File I/O error: {ex.Message}");
}
catch (Exception ex)
{
    Console.WriteLine($"General error: {ex.Message}");
}

단계 7 : 성과를 최적화

생산 환경에 대한 이러한 최적화 기술을 고려하십시오 :

메모리 스트림을 사용하여 디스크 I/O를 최소화하기 위해 높은 볼륨 처리
배치 보호 작업을위한 병렬 처리 구현
메모리 유출을 피하기 위해 자원을 적절하게 풀어주십시오.

// Example of using memory stream for improved performance
public void ProtectSpreadsheetWithMemoryStream(string inputFilePath, string password)
{
    LowCodeLoadOptions loadOptions = new LowCodeLoadOptions
    {
        InputFile = inputFilePath
    };
    
    LowCodeSaveOptions saveOptions = new LowCodeSaveOptions
    {
        SaveFormat = SaveFormat.Xlsx
    };
    
    // Use memory stream for the output
    using (MemoryStream outputStream = new MemoryStream())
    {
        saveOptions.OutputStream = outputStream;
        
        // Apply protection
        SpreadsheetLocker.Process(loadOptions, saveOptions, password, null);
        
        // Reset stream position
        outputStream.Seek(0, SeekOrigin.Begin);
        
        // Save to file if needed, or use the stream directly
        using (FileStream fileStream = File.Create("protected_output.xlsx"))
        {
            outputStream.CopyTo(fileStream);
        }
    }
}

단계 8 : 완전한 구현 예제

다음은 전체 프로세스를 보여주는 완전한 작업 예입니다 :

using System;
using System.IO;
using Aspose.Cells;
using Aspose.Cells.LowCode;
using Aspose.Cells.Utility;

namespace SpreadsheetProtectionExample
{
    class Program
    {
        static void Main(string[] args)
        {
            try
            {
                // Input file path
                string inputFile = "mytemplate.xlsx";
                
                // Method 1: Simple file-to-file protection
                ProtectExcelFile(inputFile, "result\\ProtectedFile.xlsx", "MySecurePassword123");
                
                // Method 2: Using memory stream for output
                ProtectExcelFileToMemory(inputFile, "MySecurePassword123");
                
                // Method 3: Verify password protection
                VerifyPasswordProtection("result\\ProtectedFile.xlsx", "MySecurePassword123");
                
                Console.WriteLine("All operations completed successfully.");
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Error in main process: {ex.Message}");
            }
        }
        
        static void ProtectExcelFile(string inputPath, string outputPath, string password)
        {
            // Ensure output directory exists
            string outputDir = Path.GetDirectoryName(outputPath);
            if (!Directory.Exists(outputDir) && !string.IsNullOrEmpty(outputDir))
            {
                Directory.CreateDirectory(outputDir);
            }
            
            // Configure loading options
            LowCodeLoadOptions loadOptions = new LowCodeLoadOptions
            {
                InputFile = inputPath
            };
            
            // Configure saving options
            LowCodeSaveOptions saveOptions = new LowCodeSaveOptions
            {
                OutputFile = outputPath,
                SaveFormat = SaveFormat.Xlsx
            };
            
            // Execute the protection process
            SpreadsheetLocker.Process(loadOptions, saveOptions, password, null);
            
            Console.WriteLine($"File protected and saved to: {outputPath}");
        }
        
        static void ProtectExcelFileToMemory(string inputPath, string password)
        {
            // Configure loading options
            LowCodeLoadOptions loadOptions = new LowCodeLoadOptions
            {
                InputFile = inputPath
            };
            
            // Configure memory stream output
            using (MemoryStream ms = new MemoryStream())
            {
                LowCodeSaveOptions saveOptions = new LowCodeSaveOptions
                {
                    OutputStream = ms,
                    SaveFormat = SaveFormat.Xlsx
                };
                
                // Execute the protection process
                SpreadsheetLocker.Process(loadOptions, saveOptions, password, null);
                
                // Demonstrate that the stream contains a valid Excel file
                ms.Seek(0, SeekOrigin.Begin);
                FileFormatInfo formatInfo = FileFormatUtil.DetectFileFormat(ms);
                Console.WriteLine($"Memory stream contains file format: {formatInfo.FormatType}");
                
                // Demonstrate protection by attempting to open without password
                ms.Seek(0, SeekOrigin.Begin);
                try
                {
                    new Workbook(ms);
                    Console.WriteLine("Warning: File is not properly protected!");
                }
                catch (CellsException ex)
                {
                    if (ex.Code == ExceptionType.IncorrectPassword)
                    {
                        Console.WriteLine("Success: Memory stream contains password-protected Excel file.");
                    }
                    else
                    {
                        throw;
                    }
                }
            }
        }
        
        static void VerifyPasswordProtection(string filePath, string password)
        {
            Console.WriteLine($"Verifying password protection for: {filePath}");
            
            // First, verify the file exists
            if (!File.Exists(filePath))
            {
                Console.WriteLine("Error: File not found!");
                return;
            }
            
            // Check if file requires a password
            using (FileStream fs = File.OpenRead(filePath))
            {
                bool isPasswordProtected = FileFormatUtil.DetectFileFormat(fs).IsEncrypted;
                Console.WriteLine($"File encryption detection: {isPasswordProtected}");
            }
            
            // Test opening with incorrect password
            try
            {
                new Workbook(filePath, new LoadOptions { Password = "WrongPassword" });
                Console.WriteLine("Warning: File opened with incorrect password!");
            }
            catch (CellsException ex)
            {
                if (ex.Code == ExceptionType.IncorrectPassword)
                {
                    Console.WriteLine("Password verification passed: File rejected wrong password.");
                }
                else
                {
                    Console.WriteLine($"Unexpected error: {ex.Message}");
                }
            }
            
            // Test opening with correct password
            try
            {
                new Workbook(filePath, new LoadOptions { Password = password });
                Console.WriteLine("Success: File opened successfully with correct password.");
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Error opening with correct password: {ex.Message}");
            }
        }
    }
}

사례 및 응용 프로그램 사용

기업 보고 시스템

조직은 보고 작업 흐름에 암호 보호를 통합하여 재무 보고서, 행정부 및 민감한 비즈니스 인텔리전스 스파이더가 권한을 부여받은 직원에게만 접근할 수 있도록 할 수 있습니다.이것은 데이터 개인 정보 보호 규정 및 기업 보안 정책 준수에 특히 중요합니다.

문서 관리 작업 흐름

문서 라이프 사이클 관리를 실행할 때, 암호 보호는 기밀 정보를 포함하는 Excel 문서를위한 필수 보안 레이어로 사용됩니다.문서 관리 시스템과의 통합은 콘텐츠 분류 또는 메타 데이터를 기반으로 새로 만든 또는 수정 된 스파이더를 자동으로 보호 할 수 있습니다.

지적재산권 보호

소유 Excel 모델, 금융 템플릿 또는 데이터 분석 도구를 개발하는 회사는 고객이나 파트너에게 이러한 자산을 배포할 때 자신의 지적 재산성을 보호하기 위해 암호 보호를 사용할 수 있으며 가치있는 수식, 매크로 및 구조가 쉽게 복사하거나 수정되지 않도록 보장합니다.

일반적인 도전과 해결책

도전 1 : 안전과 사용 가능성을 균형 잡는 방법

솔루션: 스프레이시트의 다른 요소가 적절한 수준의 보안을 가지고 있는 등급 보호 전략을 구현합니다.예를 들어, 구조 보호를 사용하여 배열의 무결성을 유지하면서 특정 셀에 데이터를 입력할 수 있으며, 파일 레벨 암호 보호와 결합되어 있습니다.

도전 2 : 여러 파일을 통한 암호 관리

솔루션: 응용 프로그램에 통합된 중앙 암호 관리 시스템을 만들고, 하드 코딩 대신 안전한 인증 저장 또는 핵심 관리 서비스를 이용할 수 있습니다.

도전 3 : 다른 Excel 형식에 대한 보호

솔루션: 다양한 Excel 형식 (XLSX, XLSB,XLS)에서 보호 구현을 테스트하여 호환성을 보장합니다. Aspose.Cells는 여러 형식을 위한 보호를 지원하지만 SaveFormat 속성을 다음과 같이 조정해야 할 수 있습니다.

// For XLSB format
saveOptions.SaveFormat = SaveFormat.Xlsb;

// For legacy XLS format
saveOptions.SaveFormat = SaveFormat.Excel97To2003;

성과 고려 사항

높은 볼륨 처리 시나리오를 위해 디스크 I/O 대신 메모리 스트림을 사용하십시오.
여러 파일을 보호하기 위해 병렬 실행을 가진 배치 처리 구현
큰 파일에 암호화 알고리즘의 상단을 고려하고 충분한 자원을 할당
메모리 유출을 방지하기 위해 ‘사용’ 진술을 올바르게 사용하여 자원을 풀어주십시오.

모범 사례

생산 코드에 단단한 암호를 결코 입력하지 마십시오; 구성 시스템이나 바울에서 안전하게 복구하십시오.
강력한 보호를 위해 암호 복잡성 요구 사항을 구현
파일 암호 보호와 워크시트 수준 또는 범위 수준의 보호를 결합하여 깊은 방어를 고려하십시오.
파일이 보안되었을 때 그리고 어떤 프로세스를 통해 추적할 수 있는 보호 감사 기록을 유지하십시오.
호환성을 보장하기 위해 다양한 Excel 버전으로 암호 보호 테스트

고급 시나리오

더 복잡한 요구 사항을 위해, 이러한 고급 구현을 고려하십시오 :

시나리오 1 : 다층 보호 전략

public void ApplyMultiLayerProtection(string inputFile, string outputFile, string filePassword)
{
    // Configure loading options
    LowCodeLoadOptions loadOptions = new LowCodeLoadOptions
    {
        InputFile = inputFile
    };
    
    // First apply workbook structure and worksheet protection
    using (Workbook workbook = new Workbook(inputFile))
    {
        // Protect workbook structure
        workbook.Settings.WriteProtection.SetPassword("StructurePassword");
        
        // Protect worksheets
        foreach (Worksheet worksheet in workbook.Worksheets)
        {
            // Apply worksheet protection with specific permissions
            worksheet.Protect(ProtectionType.All, "SheetPassword", true);
            
            // Optionally allow specific operations
            WorksheetProtection protection = worksheet.Protection;
            protection.AllowFormattingCells = true;
            protection.AllowFormattingRows = true;
            protection.AllowInsertingHyperlinks = true;
        }
        
        // Save the intermediate workbook
        workbook.Save("intermediate.xlsx");
    }
    
    // Now apply file-level encryption
    LowCodeSaveOptions saveOptions = new LowCodeSaveOptions
    {
        InputFile = "intermediate.xlsx",
        OutputFile = outputFile,
        SaveFormat = SaveFormat.Xlsx
    };
    
    // Apply file password protection
    SpreadsheetLocker.Process(loadOptions, saveOptions, filePassword, null);
    
    // Clean up temporary file
    if (File.Exists("intermediate.xlsx"))
        File.Delete("intermediate.xlsx");
        
    Console.WriteLine("Multi-layer protection applied successfully");
}

시나리오 2 : 진보 보고서와 함께 배치 보호

public void BatchProtectExcelFiles(string[] inputFiles, string outputDirectory, string password)
{
    // Ensure output directory exists
    if (!Directory.Exists(outputDirectory))
    {
        Directory.CreateDirectory(outputDirectory);
    }
    
    int totalFiles = inputFiles.Length;
    int processedFiles = 0;
    int successCount = 0;
    int failCount = 0;
    
    foreach (string inputFile in inputFiles)
    {
        try
        {
            string fileName = Path.GetFileName(inputFile);
            string outputPath = Path.Combine(outputDirectory, $"Protected_{fileName}");
            
            // Configure options
            LowCodeLoadOptions loadOptions = new LowCodeLoadOptions
            {
                InputFile = inputFile
            };
            
            LowCodeSaveOptions saveOptions = new LowCodeSaveOptions
            {
                OutputFile = outputPath,
                SaveFormat = SaveFormat.Xlsx
            };
            
            // Apply protection
            SpreadsheetLocker.Process(loadOptions, saveOptions, password, null);
            
            successCount++;
            Console.WriteLine($"Protected {fileName} successfully");
        }
        catch (Exception ex)
        {
            failCount++;
            Console.WriteLine($"Failed to protect {Path.GetFileName(inputFile)}: {ex.Message}");
        }
        
        processedFiles++;
        
        // Report progress
        double progressPercentage = (double)processedFiles / totalFiles * 100;
        Console.WriteLine($"Progress: {progressPercentage:F1}% ({processedFiles}/{totalFiles})");
    }
    
    Console.WriteLine($"Batch protection complete. Success: {successCount}, Failed: {failCount}");
}

결론

Aspose.Cells LowCode Spreadsheet Locker를 구현함으로써 민감한 Excel 문서를 효율적으로 보호하고 최소한의 코딩 노력으로 지적 재산을 보호할 수 있습니다.이 접근 방식은 문서 보안 조치를 실행하는 것을 크게 단순화하고 다양한 보호 요구 사항에 대한 유연성을 유지합니다.

더 많은 정보와 추가 예제는 다음과 같습니다. Aspose.Cells.LowCode API 참조 .