public static class EncodingUtils
    {
        internal static IntPtr StringToPtrUni(string value)
        {
            if (value == null)
            {
                return IntPtr.Zero;
            }

            if (Environment.OSVersion.Platform == PlatformID.Unix)
            {
                return StringToPtrUTF32(value);
            }

            return Marshal.StringToHGlobalUni(value);
        }

        private static IntPtr StringToPtrUTF32(string value)
        {
            var enc = Encoding.UTF32;
            var utf32Bytes = new byte[enc.GetByteCount(value) + 4];
            enc.GetBytes(value, 0, value.Length, utf32Bytes, 0);
            var ptr = Marshal.AllocHGlobal(utf32Bytes.Length);
            Marshal.Copy(utf32Bytes, 0, ptr, utf32Bytes.Length);
            return ptr;
        }
    }

    internal class UnmanageMemoryHolder : IDisposable
    {
        private List<IntPtr> _globalAllocations = new List<IntPtr>();
        public void Dispose()
        {
            foreach (var globalAllocation in _globalAllocations)
            {
                Marshal.FreeHGlobal(globalAllocation);
            }
           _globalAllocations.Clear();
        }

        public IntPtr GetUniStringPtr(string strValue)
        {
            IntPtr ptr = EncodingUtils.StringToPtrUni(strValue);
            _globalAllocations.Add(ptr);
            return ptr;
        }
    }

        [DllImport(s_Advapi32Dll, BestFitMapping = false, CharSet = CharSet.Auto, SetLastError = true,
                ThrowOnUnmappableChar = true, EntryPoint = "CryptAcquireContextW")]
        [return: MarshalAs(UnmanagedType.Bool)]
        private static extern bool CryptAcquireContext([In] [Out] ref SafeCryptProvHandle hProv,
                                                        [In] IntPtr pszContainer,
                                                        [In] IntPtr pszProvider,
                                                        [In] int dwProvType,
                                                        [In] [MarshalAs(UnmanagedType.U4)] AcqureContextFlags dwFlags);
        internal static bool AcquireContext([In] [Out] ref SafeCryptProvHandle hProv,
                                                        string pszContainer,
                                                        string pszProvider,
                                                        int dwProvType,
                                                        AcqureContextFlags dwFlags)
        {
            var containerPtr = IntPtr.Zero;
            var provPtr = IntPtr.Zero;
            using (var holder = new UnmanageMemoryHolder())
            {
                containerPtr = pszContainer == null 
                            ? IntPtr.Zero
                            : holder.GetUniStringPtr(pszContainer);
                provPtr = pszProvider == null 
                            ? IntPtr.Zero
                            : holder.GetUniStringPtr(pszProvider);
                bool ret = CryptAcquireContext(ref hProv, containerPtr, provPtr, dwProvType, dwFlags);
                if (ret)
                    return ret;

                int hr = Crypt32.GetLastError();
                if (hr == CryptErrors.ERROR_NO_UNICODE_TRANSLATION)
                {
                    containerPtr = pszContainer == null
                                ? IntPtr.Zero
                                : holder.GetAnsiStringPtr(pszContainer);
                    provPtr = pszProvider == null 
                                ? IntPtr.Zero
                                : holder.GetAnsiStringPtr(pszProvider);
                    return CryptAcquireContext(ref hProv, containerPtr, provPtr, dwProvType, dwFlags);
                }
            }
            return false;
        }
    }