[StructLayout(LayoutKind.Sequential)]
        public struct CMSG_ENVELOPED_ENCODE_INFO
        {
            public int cbSize;
            public IntPtr hCryptProv;
            public CRYPT_ALGORITHM_IDENTIFIER ContentEncryptionAlgorithm;
            public IntPtr pvEncryptionAuxInfo;
            public int cRecipients;
            public IntPtr rgpRecipients;
            public IntPtr rgCmsRecipients;
            public int cCertEncoded;
            public IntPtr rgCertEncoded;
            public int cCrlEncoded;
            public IntPtr rgCrlEncoded;
            public int cAttrCertEncoded;
            public IntPtr rgAttrCertEncoded;
            public int cUnprotectedAttr;
            public IntPtr rgUnprotectedAttr;
        }

                Int32 flags = 0;
                flags = CMSWin32.CMSG_CONTENTS_OCTETS_FLAG;

                hMsg = CMSWin32.CryptMsgOpenToEncode(
                    CMSWin32.X509_ASN_ENCODING | CMSWin32.PKCS_7_ASN_ENCODING,
                    flags, CMSWin32.CMSG_ENVELOPED, ref EnvelopedEncodeInfo, null,
                    ref StreamInfo);

                
// заполняется структура CMSWin32.CMSG_ENVELOPED_ENCODE_INFO EnvelopedEncodeInfo;
                // заполняется структура CMSWin32.CMSG_ENVELOPED_ENCODE_INFO EnvelopedEncodeInfo;
                EnvelopedEncodeInfo = new CMSWin32.CMSG_ENVELOPED_ENCODE_INFO();
                EnvelopedEncodeInfo.cbSize = Marshal.SizeOf(EnvelopedEncodeInfo);
                //распределяем память под структуру
                EnvelopedEncodeInfoPtr = Marshal.AllocHGlobal(
                    Marshal.SizeOf(EnvelopedEncodeInfo));
                Marshal.StructureToPtr(EnvelopedEncodeInfo, EnvelopedEncodeInfoPtr, false);
                //сертификат(ы) с публичным ключом, на котором (на которых) шифруем
                EnvelopedEncodeInfo.cCertEncoded  = CertBlobs.Length;
                CertBlobsPtr = Marshal.AllocHGlobal(
                    Marshal.SizeOf(CertBlobs[0]) * CertBlobs.Length);
                for (int i = 0; i < CertBlobs.Length; i++)
                {
                    Marshal.StructureToPtr(CertBlobs[i], new IntPtr(
                        CertBlobsPtr.ToInt64() +
                        (Marshal.SizeOf(CertBlobs[i]) * i)), false);
                }
                //это сертификаты получателя?!
                EnvelopedEncodeInfo.rgCertEncoded = CertBlobsPtr;
                //а тогда это что?
                EnvelopedEncodeInfo.cRecipients = ????????;
                EnvelopedEncodeInfo.ContentEncryptionAlgorithm.pszObjId = CMSWin32.szOID_CP_GOST_R3411;

                hMsg = CMSWin32.CryptMsgOpenToEncode(
                    CMSWin32.X509_ASN_ENCODING | CMSWin32.PKCS_7_ASN_ENCODING,
                    flags, CMSWin32.CMSG_ENVELOPED, ref EnvelopedEncodeInfo, null,
                    ref StreamInfo);

        public void Encode(X509Certificate2 cert, FileStream inFile, 
            FileStream outFile, bool detached = false)
        {
            CMSWin32.CMSG_STREAM_INFO StreamInfo;
            CMSWin32.CMSG_ENVELOPED_ENCODE_INFO EnvelopedEncodeInfo;
            CMSWin32.CERT_CONTEXT[] CertContexts = null;
            CMSWin32.BLOB[] CertBlobs;

            X509Chain chain = null;
            X509ChainElement[] chainElements = null;
            X509Certificate2[] certs = null;
            AsymmetricAlgorithm key = null;
            ICspAsymmetricAlgorithm ikey = null;
            GCHandle gchandle = new GCHandle();

            IntPtr hProv = IntPtr.Zero;
            IntPtr SignerInfoPtr = IntPtr.Zero;
            IntPtr EnvelopedEncodeInfoPtr = IntPtr.Zero;
            IntPtr CertBlobsPtr = IntPtr.Zero;
            IntPtr hMsg = IntPtr.Zero;
            IntPtr pbPtr = IntPtr.Zero;
            Byte[] pbData;
            long dwFileSize;
            long dwRemaining;
            int dwSize;
            Boolean bResult = false;

            try
            {
                // Размер файла.
                dwFileSize = inFile.Length;
                // Блок кодирования
                pbData = new byte[BlockSize];

                // поток закодированных данных
                m_callbackFile = outFile;

                if (cert != null)   //если сертификат
                {
                    // Строим цепочку сертификатов.
                    chain = new X509Chain(true);
                    chain.Build(cert);
                    chainElements = new X509ChainElement[
                        chain.ChainElements.Count];
                    chain.ChainElements.CopyTo(chainElements, 0);

                    // Сворачиваем цепочку в массив
                    certs = new X509Certificate2[chainElements.Length/* !! */]; //=====================================================
                    for (int i = 0; i < chainElements.Length /* !! */; i++)
                    {
                        certs[i] = chainElements[i].Certificate;
                    }
                }
                else
                {
                    //пользоваться commonX509Certificale2Collection
                    certs = new X509Certificate2[commonX509Certificate2Collection.Count];
                    commonX509Certificate2Collection.CopyTo(certs, 0);
                }

                // Получаем Win32 контексты сертификатов
                CertContexts = new CMSWin32.CERT_CONTEXT[certs.Length];
                for (int i = 0; i < certs.Length; i++)
                {
                    CertContexts[i] = (CMSWin32.CERT_CONTEXT)
                        Marshal.PtrToStructure(certs[i].Handle, 
                        typeof(CMSWin32.CERT_CONTEXT));
                }

                // Получаем все сертификаты в виде BLOB
                CertBlobs = new CMSWin32.BLOB[CertContexts.Length];
                for (int i = 0; i < CertContexts.Length; i++)
                {
                    CertBlobs[i].cbData = CertContexts[i].cbCertEncoded;
                    CertBlobs[i].pbData = CertContexts[i].pbCertEncoded;
                }

                // заполняется структура CMSWin32.CMSG_ENVELOPED_ENCODE_INFO EnvelopedEncodeInfo;
                EnvelopedEncodeInfo = new CMSWin32.CMSG_ENVELOPED_ENCODE_INFO();
                EnvelopedEncodeInfo.cbSize = Marshal.SizeOf(EnvelopedEncodeInfo);
                //распределяем память под структуру
                EnvelopedEncodeInfoPtr = Marshal.AllocHGlobal(
                    Marshal.SizeOf(EnvelopedEncodeInfo));
                Marshal.StructureToPtr(EnvelopedEncodeInfo, EnvelopedEncodeInfoPtr, false);
                //сертификат(ы) с публичным ключом, на котором (на которых) шифруем
                EnvelopedEncodeInfo.cCertEncoded  = CertBlobs.Length;
                CertBlobsPtr = Marshal.AllocHGlobal(
                    Marshal.SizeOf(CertBlobs[0]) * CertBlobs.Length);
                for (int i = 0; i < CertBlobs.Length; i++)
                {
                    Marshal.StructureToPtr(CertBlobs[i], new IntPtr(
                        CertBlobsPtr.ToInt64() +
                        (Marshal.SizeOf(CertBlobs[i]) * i)), false);
                }
                //это сертификаты получателя
                EnvelopedEncodeInfo.rgCertEncoded = CertBlobsPtr;
                //это количество сертификатов
                EnvelopedEncodeInfo.cRecipients = CertBlobs.Length;
                EnvelopedEncodeInfo.ContentEncryptionAlgorithm.pszObjId = "1.2.643.2.2.21";


                // Заполняем структуру StreamInfo
                StreamInfo = new CMSWin32.CMSG_STREAM_INFO();
                if( dwFileSize > Int32.MaxValue )
                    StreamInfo.cbContent = -1; // Используем BER
                else
                    StreamInfo.cbContent = (int)dwFileSize; // Используем DER
                StreamInfo.pfnStreamOutput = new 
                    CMSWin32.StreamOutputCallbackDelegate(StreamOutputCallback);

                // Открываем сообщение для кодирования
                Int32 flags = 0;    //должен быть 0!

                hMsg = CMSWin32.CryptMsgOpenToEncode(
                    CMSWin32.X509_ASN_ENCODING | CMSWin32.PKCS_7_ASN_ENCODING,
                    flags, CMSWin32.CMSG_ENVELOPED, ref EnvelopedEncodeInfo, null,
                    ref StreamInfo);

                if (hMsg.Equals(IntPtr.Zero))
                {
                    throw new CryptographicException(
                        "CryptMsgOpenToEncode error #" + 
                        Marshal.GetLastWin32Error().ToString(), 
                        new Win32Exception(Marshal.GetLastWin32Error()));
                }

                // Поблочная обработка сообщения
                gchandle = GCHandle.Alloc(pbData, GCHandleType.Pinned);
                pbPtr = gchandle.AddrOfPinnedObject();
                dwRemaining = dwFileSize;
                if (dwFileSize < BlockSize)
                    dwSize = (int)dwFileSize;
                else
                    dwSize = BlockSize;
                while (dwRemaining > 0)
                {
                    inFile.Read(pbData, 0, dwSize);
                    // Вызываем обработку блока
                    bResult = CMSWin32.CryptMsgUpdate(
                        hMsg, 
                        pbPtr, 
                        dwSize,
                        (dwRemaining <= dwSize) ? true : false );

                    if (!bResult)
                    {
                        throw new CryptographicException(
                            "CryptMsgUpdate error #" + 
                            Marshal.GetLastWin32Error().ToString(), 
                            new Win32Exception(Marshal.GetLastWin32Error()));
                    }

                    // Переходим к следующему блоку
                    dwRemaining -= dwSize;
                    if (dwRemaining < dwSize)
                    {
                        dwSize = (int)dwRemaining;
                    }
                    if (progress != null)
                        progress(dwFileSize, dwRemaining);
                }
            }
            finally
            {
                // Чистим
                if (gchandle.IsAllocated)
                {
                    gchandle.Free();
                }
                if (!CertBlobsPtr.Equals(IntPtr.Zero))
                {
                    Marshal.FreeHGlobal(CertBlobsPtr);
                }
                
                if (!EnvelopedEncodeInfoPtr.Equals(IntPtr.Zero))
                {
                    Marshal.FreeHGlobal(EnvelopedEncodeInfoPtr);
                }

                if (!hProv.Equals(IntPtr.Zero))
                {
                    CMSWin32.CryptReleaseContext(hProv, 0);
                }
                if (!hMsg.Equals(IntPtr.Zero))
                {
                    CMSWin32.CryptMsgClose(hMsg);
                }
            }
        }

                if (!EnvelopedEncodeInfoPtr.Equals(IntPtr.Zero))
                {
                    Marshal.FreeHGlobal(EnvelopedEncodeInfoPtr);
                }