Repository: dotnet/runtime
File: src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/SafeEvpPKeyHandle.OpenSsl.cs (C#)

Code before:
            SetHandle(IntPtr.Zero);
            return true;
        }

        public override bool IsInvalid
        {
            get { return handle == IntPtr.Zero; }
        }

        /// <summary>
        /// Create another instance of SafeEvpPKeyHandle which has an independent lifetime
        /// from this instance, but tracks the same resource.
        /// </summary>
        /// <returns>An equivalent SafeEvpPKeyHandle with a different lifetime</returns>
        public SafeEvpPKeyHandle DuplicateHandle()
        {
            if (IsInvalid)
                throw new InvalidOperationException(SR.Cryptography_OpenInvalidHandle);

            // Reliability: Allocate the SafeHandle before calling UpRefEvpPkey so
            // that we don't lose a tracked reference in low-memory situations.
            SafeEvpPKeyHandle safeHandle = new SafeEvpPKeyHandle();

            // Capture handle and ExtraHandle before UpRefEvpPkey so that a concurrent
            // Dispose cannot zero the fields between UpRef and the copy below.
            IntPtr currentHandle = handle;
            IntPtr currentExtraHandle = ExtraHandle;

            int success = Interop.Crypto.UpRefEvpPkey(this);

            if (success != 1)
            {
                Debug.Fail("Called UpRefEvpPkey on a key which was already marked for destruction");
                Exception e = Interop.Crypto.CreateOpenSslCryptographicException();
                safeHandle.Dispose();
                throw e;
            }

            // Since we didn't actually create a new handle, copy the handle
            // to the new SafeHandle.
            safeHandle.SetHandle(currentHandle);
            // ExtraHandle is upref'd by UpRefEvpPkey
            safeHandle.ExtraHandle = currentExtraHandle;
            return safeHandle;
        }

        /// <summary>
        ///   Open a named private key using a named OpenSSL <code>ENGINE</code>.
        /// </summary>
        /// <param name="engineName">
        ///   The name of the <code>ENGINE</code> to process the private key open request.

Review comment (suggestion):
@copilot Please revert this file to the previous commit. It turns out we want to keep the add ref / release approach. The test changes are fine.

Code after:
            SetHandle(IntPtr.Zero);
            return true;
        }

        public override bool IsInvalid
        {
            get { return handle == IntPtr.Zero; }
        }

        /// <summary>
        /// Create another instance of SafeEvpPKeyHandle which has an independent lifetime
        /// from this instance, but tracks the same resource.
        /// </summary>
        /// <returns>An equivalent SafeEvpPKeyHandle with a different lifetime</returns>
        public SafeEvpPKeyHandle DuplicateHandle()
        {
            if (IsInvalid)
                throw new InvalidOperationException(SR.Cryptography_OpenInvalidHandle);

            // Keep the source handle alive so that a concurrent Dispose on another
            // thread does not zero the handle field between UpRef and the copy below.
            bool addedRef = false;

            try
            {
                DangerousAddRef(ref addedRef);

                // Reliability: Allocate the SafeHandle before calling UpRefEvpPkey so
                // that we don't lose a tracked reference in low-memory situations.
                SafeEvpPKeyHandle safeHandle = new SafeEvpPKeyHandle();

                int success = Interop.Crypto.UpRefEvpPkey(this);

                if (success != 1)
                {
                    Debug.Fail("Called UpRefEvpPkey on a key which was already marked for destruction");
                    Exception e = Interop.Crypto.CreateOpenSslCryptographicException();
                    safeHandle.Dispose();
                    throw e;
                }

                // Since we didn't actually create a new handle, copy the handle
                // to the new SafeHandle. DangerousAddRef prevents ReleaseHandle
                // from being called, so handle and ExtraHandle are stable here.
                safeHandle.SetHandle(handle);
                // ExtraHandle is upref'd by UpRefEvpPkey
                safeHandle.ExtraHandle = ExtraHandle;
                return safeHandle;
            }
            finally
            {