Cryptography.cs

// =============================================================================
// GPAL - Generally Positive Automation Library
// Copyright © 2026 Software Decisions, Inc. All rights reserved.
//
// This file is part of GPAL.
// Licensed under the Business Source License 1.1
//
// Primary development, architecture, and vision by Michael B. Vederman,
// CEO of Software Decisions, Inc., Texas.
//
// Internal development maintained privately.
// Public releases appear on GitHub: https://github.com/SoftwareDecisionsInc/GPAL.
//
// See LICENSE for full terms, including Additional Use Grant.
// =============================================================================
 
using System;
using DocumentFormat.OpenXml.Drawing;
using DocumentFormat.OpenXml.ExtendedProperties;
using DocumentFormat.OpenXml.Math;
using Org.BouncyCastle.Asn1.Pkcs;
using Org.BouncyCastle.Asn1.X509;
using Org.BouncyCastle.Crypto;
using Org.BouncyCastle.Crypto.Engines;
using Org.BouncyCastle.Crypto.Generators;
using Org.BouncyCastle.Crypto.Modes;
using Org.BouncyCastle.Crypto.Paddings;
using Org.BouncyCastle.Crypto.Parameters;
using Org.BouncyCastle.Pkcs;
using Org.BouncyCastle.Security;
using Org.BouncyCastle.X509;
using static GenerallyPositive.Enums;
 
namespace GenerallyPositive
{
    public class Cryptography : ICryptography
    {
        private CryptoAlgorithm _algorithm = CryptoAlgorithm.AES; // Default
        private byte[] _key;
        private byte[] _iv;
        private CryptoMode _mode = CryptoMode.GCM; // Default
        private CryptoPadding _padding = CryptoPadding.PKCS7; // Default
        private byte[] _salt;
        private int _iterationCount = 10000; // Default for PBKDF2
        private byte[] _inputData;
        private byte[] _signature; // Added for verification
 
        internal Cryptography()
        { }
 
        public IAllowCryptoConfig WithAlgorithm(CryptoAlgorithm alg)
        {
            _algorithm = alg;
            return this;
        }
 
        public IAllowCryptoConfig WithKey(byte[] key)
        {
            _key = key;
            return this;
        }
 
        public IAllowCryptoConfig WithIV(byte[] iv)
        {
            _iv = iv;
            return this;
        }
 
        public IAllowCryptoConfig WithMode(CryptoMode mode)
        {
            _mode = mode;
            return this;
        }
 
        public IAllowCryptoConfig WithPadding(CryptoPadding padding)
        {
            _padding = padding;
            return this;
        }
 
        public IAllowCryptoConfig WithSalt(byte[] salt)
        {
            _salt = salt;
            return this;
        }
 
        public IAllowCryptoConfig WithSignature(byte[] signature)
        {
            _signature = signature;
            return this;
        }
        public IAllowCryptoConfig WithIterationCount(int count)
        {
            if (count <= 0)
            {
                GPAL.PublishSimpleEvent(GPALEventType.WARNING, $"Iteration count [{count}] is invalid, using default [{_iterationCount}]", this, GPALObjectType.Cryptography);
                return this;
            }
            _iterationCount = count;
            return this;
        }
 
        public IAllowCryptoAction WithInputData(byte[] data)
        {
            _inputData = data;
            return this;
        }
 
        public IAllowCryptoConfig GenerateIV(out byte[] iv)
        {
            iv = null;
            if (_algorithm != CryptoAlgorithm.AES)
            {
                GPAL.PublishSimpleEvent(GPALEventType.WARNING, $"Algorithm [{_algorithm}] not supported for IV generation, defaulting to AES", this, GPALObjectType.Cryptography);
                _algorithm = CryptoAlgorithm.AES;
            }
            if (_mode == CryptoMode.ECB)
            {
                GPAL.PublishSimpleEvent(GPALEventType.WARNING, "IV generation not required for ECB mode", this, GPALObjectType.Cryptography);
                return this;
            }
 
            GPAL.PublishSimpleEvent(GPALEventType.INFO,
                $"Generating IV for algorithm [{_algorithm}], mode [{_mode}]",
                this, GPALObjectType.Cryptography);
 
            try
            {
                int ivSize = _mode == CryptoMode.GCM ? 12 : 16; // 12 bytes for GCM, 16 for CBC
                iv = new byte[ivSize];
                var random = new SecureRandom();
                random.NextBytes(iv);
            }
            catch (Exception ex)
            {
                GPAL.PublishSimpleEvent(GPALEventType.EXCEPTION, "IV generation failed", this, GPALObjectType.Cryptography, ex);
                iv = null;
            }
 
            _iv = iv; // Store for state reuse
            return this;
        }
 
        public IAllowCryptoConfig Encrypt(out byte[] encryptedData)
        {
            encryptedData = null;
            if (_key == null)
            {
                GPAL.PublishSimpleEvent(GPALEventType.ERROR, "Cannot encrypt: missing key", this, GPALObjectType.Cryptography);
                return this;
            }
            if (_inputData == null)
            {
                GPAL.PublishSimpleEvent(GPALEventType.ERROR, "Cannot encrypt: missing input data", this, GPALObjectType.Cryptography);
                return this;
            }
            if (_mode != CryptoMode.ECB && _iv == null)
            {
                GPAL.PublishSimpleEvent(GPALEventType.WARNING, $"IV is required for mode [{_mode}], defaulting to ECB", this, GPALObjectType.Cryptography);
                _mode = CryptoMode.ECB;
            }
 
            GPAL.PublishSimpleEvent(GPALEventType.INFO,
                $"Encrypting with algorithm [{_algorithm}], mode [{_mode}], padding [{_padding}]",
                this, GPALObjectType.Cryptography);
 
            try
            {
                encryptedData = PerformEncryption();
            }
            catch (Exception ex)
            {
                GPAL.PublishSimpleEvent(GPALEventType.EXCEPTION, "Encryption failed", this, GPALObjectType.Cryptography, ex);
                encryptedData = null;
            }
            return this;
        }
 
        public IAllowCryptoConfig Decrypt(out string decryptedValue)
        {
            decryptedValue = null;
            if (_key == null)
            {
                GPAL.PublishSimpleEvent(GPALEventType.ERROR, "Cannot decrypt: missing key", this, GPALObjectType.Cryptography);
                return this;
            }
            if (_inputData == null)
            {
                GPAL.PublishSimpleEvent(GPALEventType.ERROR, "Cannot decrypt: missing input data", this, GPALObjectType.Cryptography);
                return this;
            }
            if (_mode != CryptoMode.ECB && _iv == null)
            {
                GPAL.PublishSimpleEvent(GPALEventType.WARNING, $"IV is required for mode [{_mode}], defaulting to ECB", this, GPALObjectType.Cryptography);
                _mode = CryptoMode.ECB;
            }
 
            GPAL.PublishSimpleEvent(GPALEventType.INFO,
                $"Decrypting with algorithm [{_algorithm}], mode [{_mode}], padding [{_padding}]",
                this, GPALObjectType.Cryptography);
 
            try
            {
                byte[] decryptedBytes = PerformDecryption();
                decryptedValue = System.Text.Encoding.UTF8.GetString(decryptedBytes);
            }
            catch (Exception ex)
            {
                GPAL.PublishSimpleEvent(GPALEventType.EXCEPTION, "Decryption failed", this, GPALObjectType.Cryptography, ex);
                decryptedValue = null;
            }
            return this;
        }
 
        public IAllowCryptoConfig Sign(out byte[] signature)
        {
            signature = null;
            if (_key == null)
            {
                GPAL.PublishSimpleEvent(GPALEventType.ERROR, "Cannot sign: missing key", this, GPALObjectType.Cryptography);
                return this;
            }
            if (_inputData == null)
            {
                GPAL.PublishSimpleEvent(GPALEventType.ERROR, "Cannot sign: missing input data", this, GPALObjectType.Cryptography);
                return this;
            }
 
            GPAL.PublishSimpleEvent(GPALEventType.INFO,
                $"Signing with algorithm [{_algorithm}]",
                this, GPALObjectType.Cryptography);
 
            try
            {
                signature = PerformSigning();
            }
            catch (Exception ex)
            {
                GPAL.PublishSimpleEvent(GPALEventType.EXCEPTION, "Signing failed", this, GPALObjectType.Cryptography, ex);
                signature = null;
            }
            return this;
        }
 
        public IAllowCryptoConfig Verify(out bool isValid)
        {
            isValid = false;
            if (_key == null)
            {
                GPAL.PublishSimpleEvent(GPALEventType.ERROR, "Cannot verify: missing key", this, GPALObjectType.Cryptography);
                return this;
            }
            if (_inputData == null)
            {
                GPAL.PublishSimpleEvent(GPALEventType.ERROR, "Cannot verify: missing input data", this, GPALObjectType.Cryptography);
                return this;
            }
            if (_signature == null)
            {
                GPAL.PublishSimpleEvent(GPALEventType.ERROR, "Cannot verify: missing signature", this, GPALObjectType.Cryptography);
                return this;
            }
 
            GPAL.PublishSimpleEvent(GPALEventType.INFO,
                $"Verifying with algorithm [{_algorithm}]",
                this, GPALObjectType.Cryptography);
 
            try
            {
                isValid = PerformVerification();
            }
            catch (Exception ex)
            {
                GPAL.PublishSimpleEvent(GPALEventType.EXCEPTION, "Verification failed", this, GPALObjectType.Cryptography, ex);
                isValid = false;
            }
            return this;
        }
 
        public IAllowCryptoConfig Hash(out byte[] hash)
        {
            hash = null;
            if (_inputData == null)
            {
                GPAL.PublishSimpleEvent(GPALEventType.ERROR, "Cannot hash: missing input data", this, GPALObjectType.Cryptography);
                return this;
            }
 
            GPAL.PublishSimpleEvent(GPALEventType.INFO,
                $"Hashing with algorithm [{_algorithm}]" + (_salt != null ? $", salt length [{_salt.Length}]" : ""),
                this, GPALObjectType.Cryptography);
 
            try
            {
                hash = PerformHashing();
            }
            catch (Exception ex)
            {
                GPAL.PublishSimpleEvent(GPALEventType.EXCEPTION, "Hashing failed", this, GPALObjectType.Cryptography, ex);
                hash = null;
            }
            return this;
        }
 
        public IAllowCryptoConfig GenerateKey(out byte[] key)
        {
            key = null;
            if (_algorithm == CryptoAlgorithm.PBKDF2 && (_salt == null || _inputData == null))
            {
                GPAL.PublishSimpleEvent(GPALEventType.ERROR, "Cannot generate key with PBKDF2: missing salt or input data", this, GPALObjectType.Cryptography);
                return this;
            }
 
            GPAL.PublishSimpleEvent(GPALEventType.INFO,
                $"Generating key with algorithm [{_algorithm}]" + (_algorithm == CryptoAlgorithm.PBKDF2 ? $", iteration count [{_iterationCount}]" : ""),
                this, GPALObjectType.Cryptography);
 
            try
            {
                key = PerformKeyGeneration();
            }
            catch (Exception ex)
            {
                GPAL.PublishSimpleEvent(GPALEventType.EXCEPTION, "Key generation failed", this, GPALObjectType.Cryptography, ex);
                key = null;
            }
            _key = key;
            return this;
        }
 
        private byte[] PerformEncryption()
        {
            if (_algorithm != CryptoAlgorithm.AES)
            {
                GPAL.PublishSimpleEvent(GPALEventType.WARNING, $"Algorithm [{_algorithm}] not supported, defaulting to AES", this, GPALObjectType.Cryptography);
                _algorithm = CryptoAlgorithm.AES;
            }
 
            if (_mode == CryptoMode.GCM)
            {
                IAeadBlockCipher cipher = new GcmBlockCipher(new AesEngine());
                ICipherParameters parameters = new AeadParameters(new KeyParameter(_key), 128, _iv, null);
                cipher.Init(true, parameters);
                byte[] output = new byte[cipher.GetOutputSize(_inputData.Length)];
                int len = cipher.ProcessBytes(_inputData, 0, _inputData.Length, output, 0);
                cipher.DoFinal(output, len);
                return output;
            }
            else
            {
                IBufferedCipher cipher = _mode == CryptoMode.CBC
                    ? new PaddedBufferedBlockCipher(new CbcBlockCipher(new AesEngine()), new Pkcs7Padding())
                    : new PaddedBufferedBlockCipher(new AesEngine(), new Pkcs7Padding()); // ECB
 
                ICipherParameters parameters;
                if (_iv != null)
                {
                    parameters = new ParametersWithIV(new KeyParameter(_key), _iv);
                }
                else
                {
                    parameters = new KeyParameter(_key);
                }
 
                cipher.Init(true, parameters);
                return cipher.DoFinal(_inputData);
            }
        }
 
        private byte[] PerformDecryption()
        {
            if (_algorithm != CryptoAlgorithm.AES)
            {
                GPAL.PublishSimpleEvent(GPALEventType.WARNING, $"Algorithm [{_algorithm}] not supported, defaulting to AES", this, GPALObjectType.Cryptography);
                _algorithm = CryptoAlgorithm.AES;
            }
 
            if (_mode == CryptoMode.GCM)
            {
                IAeadBlockCipher cipher = new GcmBlockCipher(new AesEngine());
                ICipherParameters parameters = new AeadParameters(new KeyParameter(_key), 128, _iv, null);
                cipher.Init(false, parameters);
                byte[] output = new byte[cipher.GetOutputSize(_inputData.Length)];
                int len = cipher.ProcessBytes(_inputData, 0, _inputData.Length, output, 0);
                cipher.DoFinal(output, len);
                return output;
            }
            else
            {
                IBufferedCipher cipher = _mode == CryptoMode.CBC
                    ? new PaddedBufferedBlockCipher(new CbcBlockCipher(new AesEngine()), new Pkcs7Padding())
                    : new PaddedBufferedBlockCipher(new AesEngine(), new Pkcs7Padding()); // ECB
 
                ICipherParameters parameters;
                if (_iv != null)
                {
                    parameters = new ParametersWithIV(new KeyParameter(_key), _iv);
                }
                else
                {
                    parameters = new KeyParameter(_key);
                }
 
                cipher.Init(false, parameters);
                return cipher.DoFinal(_inputData);
            }
        }
 
        private byte[] PerformSigning()
        {
            if (_algorithm != CryptoAlgorithm.SHA256withRSA)
            {
                GPAL.PublishSimpleEvent(GPALEventType.WARNING, $"Algorithm [{_algorithm}] not supported, defaulting to SHA256withRSA", this, GPALObjectType.Cryptography);
                _algorithm = CryptoAlgorithm.SHA256withRSA;
            }
 
            AsymmetricKeyParameter keyParam;
            try
            {
                var keyInfo = PrivateKeyInfo.GetInstance(_key);
                var rsaParams = RsaPrivateKeyStructure.GetInstance(keyInfo.ParsePrivateKey());
                keyParam = new RsaKeyParameters(true, rsaParams.Modulus, rsaParams.PrivateExponent);
            }
            catch (Exception ex)
            {
                GPAL.PublishSimpleEvent(GPALEventType.ERROR, "Invalid RSA private key format", this, GPALObjectType.Cryptography, ex);
                return null;
            }
 
            ISigner signer = SignerUtilities.GetSigner("SHA256withRSA");
            signer.Init(true, keyParam);
            signer.BlockUpdate(_inputData, 0, _inputData.Length);
            return signer.GenerateSignature();
        }
 
        private bool PerformVerification()
        {
            if (_algorithm != CryptoAlgorithm.SHA256withRSA)
            {
                GPAL.PublishSimpleEvent(GPALEventType.WARNING, $"Algorithm [{_algorithm}] not supported, defaulting to SHA256withRSA", this, GPALObjectType.Cryptography);
                _algorithm = CryptoAlgorithm.SHA256withRSA;
            }
 
            AsymmetricKeyParameter keyParam;
            try
            {
                var keyInfo = SubjectPublicKeyInfo.GetInstance(_key);
                var rsaParams = RsaPublicKeyStructure.GetInstance(keyInfo.ParsePublicKey());
                keyParam = new RsaKeyParameters(false, rsaParams.Modulus, rsaParams.PublicExponent);
            }
            catch (Exception ex)
            {
                GPAL.PublishSimpleEvent(GPALEventType.ERROR, "Invalid RSA public key format", this, GPALObjectType.Cryptography, ex);
                return false;
            }
 
            ISigner signer = SignerUtilities.GetSigner("SHA256withRSA");
            signer.Init(false, keyParam);
            signer.BlockUpdate(_inputData, 0, _inputData.Length);
            return signer.VerifySignature(_signature); // Assumes _inputData is the signature
        }
 
        private byte[] PerformHashing()
        {
            if (_algorithm != CryptoAlgorithm.SHA256)
            {
                GPAL.PublishSimpleEvent(GPALEventType.WARNING, $"Algorithm [{_algorithm}] not supported, defaulting to SHA256", this, GPALObjectType.Cryptography);
                _algorithm = CryptoAlgorithm.SHA256;
            }
 
            IDigest digest = DigestUtilities.GetDigest("SHA256");
            if (_salt != null)
            {
                digest.BlockUpdate(_salt, 0, _salt.Length);
            }
            digest.BlockUpdate(_inputData, 0, _inputData.Length);
            byte[] hash = new byte[digest.GetDigestSize()];
            digest.DoFinal(hash, 0);
            return hash;
        }
 
        private byte[] PerformKeyGeneration()
        {
            if (_algorithm == CryptoAlgorithm.PBKDF2)
            {
                if (_salt == null || _inputData == null)
                {
                    GPAL.PublishSimpleEvent(GPALEventType.ERROR, "Cannot generate key with PBKDF2: missing salt or input data", this, GPALObjectType.Cryptography);
                    return null;
                }
 
                Pkcs5S2ParametersGenerator gen = new Pkcs5S2ParametersGenerator();
                gen.Init(_inputData, _salt, _iterationCount);
                return ((KeyParameter)gen.GenerateDerivedParameters("AES", 256)).GetKey();
            }
 
            if (_algorithm != CryptoAlgorithm.AES)
            {
                GPAL.PublishSimpleEvent(GPALEventType.WARNING, $"Algorithm [{_algorithm}] not supported, defaulting to AES", this, GPALObjectType.Cryptography);
                _algorithm = CryptoAlgorithm.AES;
            }
 
            var generator = GeneratorUtilities.GetKeyGenerator("AES");
            return generator.GenerateKey();
        }
        #region Helpers
        public static (byte[], byte[]) GenerateRsaKeyPair()
        {
            try
            {
                var keyPairGen = GeneratorUtilities.GetKeyPairGenerator("RSA");
                keyPairGen.Init(new KeyGenerationParameters(new SecureRandom(), 2048));
                var keyPair = keyPairGen.GenerateKeyPair();
 
                // Private key (PKCS#8)
                var privateKeyInfo = PrivateKeyInfoFactory.CreatePrivateKeyInfo(keyPair.Private);
                byte[] privateKey = privateKeyInfo.ToAsn1Object().GetDerEncoded();
 
                // Public key (X.509)
                var publicKeyInfo = SubjectPublicKeyInfoFactory.CreateSubjectPublicKeyInfo(keyPair.Public);
                byte[] publicKey = publicKeyInfo.ToAsn1Object().GetDerEncoded();
 
                return (privateKey, publicKey);
            }
            catch (Exception)
            {
                // Since not part of fluent interface, return default values instead of throwing
                return (null, null);
            }
        }
        #endregion Helpers
        public ICryptography ToGPALObject()
        {
            return this;
        }
    }
}