Wie man Passwort für Excel-Dateien in .NET schützt

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

// 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;
}

// 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
};

// 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.");

// 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}");
        }
    }
}

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}");
}

// 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);
        }
    }
}

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}");
            }
        }
    }
}