CreateSecretKey.cs

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using Net.Pkcs11Interop.Common;
using Net.Pkcs11Interop.HighLevelAPI;
using Org.BouncyCastle.Crypto;
using Org.BouncyCastle.Crypto.Engines;
using Org.BouncyCastle.Crypto.Parameters;
using Org.BouncyCastle.Utilities.Encoders;

namespace CryptokiTokenBrowser
{
    public partial class CreateSecretKey : Form
    {
        private string keyType = string.Empty;
        private string label = string.Empty;
        private string keyValue = string.Empty;
        private byte[] keyValueByte = [];
        private bool persistantFlag = false;
        private bool privateFlag = false;
        private bool sensitiveFlag = false;
        private bool modifiableFlag = false;
        private bool wrapFlag = false;
        private bool unwrapFlag = false;
        private bool extractableFlag = false;
        private bool encryptFlag = false;
        private bool decryptFlag = false;
        private bool signFlag = false;
        private bool verifyFlag = false;
        private bool deriveFlag = false;
        private bool keyNumHex = false;
        private bool keyNumAsc = false;
        public IMechanism? selectedMechanism = null;
        public ISession? session = null;
        public List<IObjectAttribute> flags = new List<IObjectAttribute>();

        public CreateSecretKey()
        {
            InitializeComponent();
        }

        public static string ComputeKcv(string keyHex, bool useZeroBlock = true)
        {
            byte[] key = Hex.Decode(keyHex);

            byte fillByte = useZeroBlock ? (byte)0x00 : (byte)0x01;
            byte[] block = new byte[16];
            for (int i = 0; i < block.Length; i++)
                block[i] = fillByte;

            IBlockCipher engine = new AesEngine();
            engine.Init(true, new KeyParameter(key));

            byte[] cipher = new byte[16];
            engine.ProcessBlock(block, 0, cipher, 0);

            return BitConverter.ToString(cipher, 0, 3).Replace("-", string.Empty);
        }

        private void BtnCancel_Click(object sender, EventArgs e)
        {
            this.Close();
        }

        private void BtnOK_Click(object sender, EventArgs e)
        {
            if (CbKeyType.SelectedItem == null)
            {
                MessageBox.Show(
                    "Please select a key type.",
                    "Error",
                    MessageBoxButtons.OK,
                    MessageBoxIcon.Error
                );
                return;
            }
            if (string.IsNullOrWhiteSpace(TxtLabel.Text))
            {
                MessageBox.Show(
                    "Please enter a label.",
                    "Error",
                    MessageBoxButtons.OK,
                    MessageBoxIcon.Error
                );
                return;
            }
            if (string.IsNullOrWhiteSpace(TxtKeyValue.Text))
            {
                MessageBox.Show(
                    "Please enter a key value.",
                    "Error",
                    MessageBoxButtons.OK,
                    MessageBoxIcon.Error
                );
                return;
            }
            if (!RadioKValueHex.Checked && !RadioKValueAsc.Checked)
            {
                MessageBox.Show(
                    "Please select a key value format (Hex or ASCII).",
                    "Error",
                    MessageBoxButtons.OK,
                    MessageBoxIcon.Error
                );
                return;
            }

            keyType = CbKeyType.SelectedItem?.ToString() ?? string.Empty;
            label = TxtLabel.Text;
            keyValue = TxtKeyValue.Text;
            keyValueByte = ConvertUtils.HexStringToBytes(keyValue);
            keyNumHex = RadioKValueHex.Checked;
            keyNumAsc = RadioKValueAsc.Checked;

            persistantFlag = CheckPersistant.Checked;
            privateFlag = CheckPrivate.Checked;
            sensitiveFlag = CheckSensitive.Checked;
            modifiableFlag = CheckModif.Checked;
            wrapFlag = CheckWrap.Checked;
            unwrapFlag = CheckUnwrap.Checked;
            extractableFlag = CheckExtractable.Checked;
            encryptFlag = CheckEnc.Checked;
            decryptFlag = CheckDec.Checked;
            signFlag = CheckSign.Checked;
            verifyFlag = CheckVerify.Checked;
            deriveFlag = CheckDerive.Checked;

            if (session == null)
            {
                return;
            }

            string kcv = ComputeKcv(keyValue, true);
            byte[] kcvBytes = ConvertUtils.HexStringToBytes(kcv);

            flags.Add(
                session.Factories.ObjectAttributeFactory.Create(CKA.CKA_CLASS, CKO.CKO_SECRET_KEY)
            );
            flags.Add(
                session.Factories.ObjectAttributeFactory.Create(CKA.CKA_TOKEN, persistantFlag)
            );
            flags.Add(
                session.Factories.ObjectAttributeFactory.Create(CKA.CKA_PRIVATE, privateFlag)
            );
            flags.Add(
                session.Factories.ObjectAttributeFactory.Create(CKA.CKA_SENSITIVE, sensitiveFlag)
            );
            flags.Add(
                session.Factories.ObjectAttributeFactory.Create(CKA.CKA_MODIFIABLE, modifiableFlag)
            );
            flags.Add(session.Factories.ObjectAttributeFactory.Create(CKA.CKA_WRAP, wrapFlag));
            flags.Add(session.Factories.ObjectAttributeFactory.Create(CKA.CKA_UNWRAP, unwrapFlag));
            flags.Add(
                session.Factories.ObjectAttributeFactory.Create(
                    CKA.CKA_EXTRACTABLE,
                    extractableFlag
                )
            );
            flags.Add(session.Factories.ObjectAttributeFactory.Create(CKA.CKA_DERIVE, deriveFlag));

            flags.Add(
                session.Factories.ObjectAttributeFactory.Create(CKA.CKA_ENCRYPT, encryptFlag)
            );
            flags.Add(
                session.Factories.ObjectAttributeFactory.Create(CKA.CKA_DECRYPT, decryptFlag)
            );
            flags.Add(session.Factories.ObjectAttributeFactory.Create(CKA.CKA_SIGN, signFlag));
            flags.Add(session.Factories.ObjectAttributeFactory.Create(CKA.CKA_VERIFY, verifyFlag));
            flags.Add(session.Factories.ObjectAttributeFactory.Create(CKA.CKA_LABEL, label));
            flags.Add(
                session.Factories.ObjectAttributeFactory.Create(CKA.CKA_KEY_TYPE, CKK.CKK_AES)
            );
            flags.Add(session.Factories.ObjectAttributeFactory.Create(CKA.CKA_VALUE, keyValueByte));

            session.CreateObject(flags);
            flags.Clear();
            this.DialogResult = DialogResult.OK;
            this.Close();
        }

        private void CreateSecretKey_Load(object sender, EventArgs e)
        {
            CheckPersistant.Checked = true;
            CheckSensitive.Checked = true;
            CheckModif.Checked = true;
            CheckUnwrap.Checked = true;
            CheckExtractable.Checked = true;
            CheckEnc.Checked = true;
            CheckDec.Checked = true;
            CheckSign.Checked = true;
            CheckVerify.Checked = true;
        }
    }
}