LegacyPassword.cs

/*
 * NanoXLSX is a small .NET library to generate and read XLSX (Microsoft Excel 2007 or newer) files in an easy and native way  
 * Copyright Raphael Stoeckli © 2025
 * This library is licensed under the MIT License.
 * You find a copy of the license in project folder or on: http://opensource.org/licenses/MIT
 */
 
using System;
using System.Collections.Generic;
using System.Runtime.InteropServices;
using System.Security;
using NanoXLSX.Interfaces;
using NanoXLSX.Utils;
 
namespace NanoXLSX
{
    public class LegacyPassword : IPassword
    {
        public enum PasswordType
        {
            WorkbookProtection,
            WorksheetProtection
        }
 
        private SecureString password;

        public PasswordType Type { get; set; }

        public string PasswordHash { get; set; }

        public LegacyPassword(PasswordType type)
        {
            this.Type = type;
            this.PasswordHash = null;
        }

        public string GetPassword()
        {
            if (password != null && password.Length > 0)
            {
                return GetPasswordOfSecureString(password);
            }
            return null;
        }

        public void SetPassword(string plainText)
        {
            if (string.IsNullOrEmpty(plainText))
            {
                UnsetPassword();
                return;
            }
            else
            {
                password = GetSecureString(plainText);
                PasswordHash = GenerateLegacyPasswordHash(plainText);
            }
        }

        public void UnsetPassword()
        {
            if (password != null)
            {
                password.Clear();
            }
            PasswordHash = null;
        }

        public bool PasswordIsSet()
        {
            return !string.IsNullOrEmpty(PasswordHash);
        }

        public void CopyFrom(IPassword passwordInstance)
        {
            this.PasswordHash = passwordInstance.PasswordHash;
            this.password = GetSecureString(passwordInstance.GetPassword());
            if (this.GetType() == passwordInstance.GetType())
            {
                this.Type = ((LegacyPassword)passwordInstance).Type;
            }
        }

        public static string GenerateLegacyPasswordHash(string password)
        {
            if (string.IsNullOrEmpty(password)) { return string.Empty; }
            int passwordLength = password.Length;
            int passwordHash = 0;
            char character;
            for (int i = passwordLength; i > 0; i--)
            {
                character = password[i - 1];
                passwordHash = ((passwordHash >> 14) & 0x01) | ((passwordHash << 1) & 0x7fff);
                passwordHash ^= character;
            }
            passwordHash = ((passwordHash >> 14) & 0x01) | ((passwordHash << 1) & 0x7fff);
            passwordHash ^= (0x8000 | ('N' << 8) | 'K');
            passwordHash ^= passwordLength;
            return passwordHash.ToString("X", ParserUtils.InvariantCulture);
        }

        private static SecureString GetSecureString(string plaintextPassword)
        {
            char[] chars;
            if (string.IsNullOrEmpty(plaintextPassword))
            {
#pragma warning disable CA1825 // Suppress: 0-length array allocation (suggestion is not .Net 5.0 compatible)
                chars = new char[0];
#pragma warning restore CA1825 // Suppress: 0-length array allocation
            }
            else
            {
                chars = plaintextPassword.ToCharArray();
            }
            SecureString str = new SecureString();
            foreach (char c in chars)
            {
                str.AppendChar(c);
            }
            return str;
        }

        private static string GetPasswordOfSecureString(SecureString secureString)
        {
            IntPtr unmanagedString = IntPtr.Zero;
            try
            {
                unmanagedString = Marshal.SecureStringToGlobalAllocUnicode(secureString);
                return Marshal.PtrToStringUni(unmanagedString);
            }
            finally
            {
                Marshal.ZeroFreeGlobalAllocUnicode(unmanagedString);
            }
        }

        public override bool Equals(object obj)
        {
            LegacyPassword pwd = (LegacyPassword)obj;
            return obj is LegacyPassword password &&
                   Comparators.CompareSecureStrings(this.password, password.password) &&
                   Type == password.Type &&
                   PasswordHash == password.PasswordHash;
        }

        public override int GetHashCode()
        {
            // The actual password is not considered since its hash is sufficient
            unchecked
            {
                var hashCode = 1034998357;
                hashCode = hashCode * -1521134295 + Type.GetHashCode();
                hashCode = hashCode * -1521134295 + EqualityComparer<string>.Default.GetHashCode(PasswordHash);
                hashCode = hashCode * -1521134295 + PasswordIsSet().GetHashCode();
                return hashCode;
            }
        }
    }
}