コード例 #1
0
        private void CopyDirectory(string sourceDirName, string destDirName)
        {
            try
            {
                if (!Directory.Exists(destDirName))
                {
                    Directory.CreateDirectory(destDirName);
                    File.SetAttributes(destDirName, File.GetAttributes(sourceDirName));
                }
                if (destDirName[destDirName.Length - 1] != Path.DirectorySeparatorChar)
                {
                    destDirName = destDirName + Path.DirectorySeparatorChar;
                }
                string[] files = Directory.GetFiles(sourceDirName);
                foreach (string file in files)
                {
                    File.Copy(file, destDirName + Path.GetFileName(file), true);
                    File.SetAttributes(destDirName + Path.GetFileName(file), FileAttributes.Normal);
                }
                string[] dirs = Directory.GetDirectories(sourceDirName);
                foreach (string dir in dirs)
                {
                    CopyDirectory(dir, destDirName + Path.GetFileName(dir));
                }
            }
            catch (Exception ex)
            {
                WriteLogHelper.WriteLog_client("CopyDirectory error", ex);
                MessageBox.Show(ex.Message);

                throw;
            }
        }
コード例 #2
0
        /// <summary>
        /// 获取远程服务器ATN结果
        /// </summary>
        /// <param name="strUrl">指定URL路径地址</param>
        /// <param name="timeout">超时时间设置</param>
        /// <returns>服务器ATN结果</returns>
        private string Get_Http(string strUrl, int timeout)
        {
            string strResult;

            try
            {
                HttpWebRequest myReq = (HttpWebRequest)HttpWebRequest.Create(strUrl);
                myReq.Timeout = timeout;
                HttpWebResponse HttpWResp  = (HttpWebResponse)myReq.GetResponse();
                Stream          myStream   = HttpWResp.GetResponseStream();
                StreamReader    sr         = new StreamReader(myStream, Encoding.Default);
                StringBuilder   strBuilder = new StringBuilder();
                while (-1 != sr.Peek())
                {
                    strBuilder.Append(sr.ReadLine());
                }

                strResult = strBuilder.ToString();
            }
            catch (Exception exp)
            {
                strResult = "错误:" + exp.Message;
                WriteLogHelper.WriteError(exp);
            }

            return(strResult);
        }
コード例 #3
0
        /// <summary>
        /// 发送短信通用接口
        /// </summary>
        /// <param name="signName">管理控制台中配置的短信签名(状态必须是验证通过)</param>
        /// <param name="templateCode">管理控制台中配置的审核通过的短信模板的模板CODE(状态必须是验证通过)</param>
        /// <param name="recNum">接收号码,多个号码可以逗号分隔</param>
        /// <param name="paramString">短信模板中的变量;数字需要转换为字符串;个人用户每个变量长度必须小于15个字符。例:{"code":"123456","product":"登录"}</param>
        /// <returns>成功返回200</returns>
        public string SingleSendSms(string signName, string templateCode, string recNum, string paramString)
        {
            IClientProfile       profile = DefaultProfile.GetProfile("cn-hangzhou", "PrDPRjqAl2epRSnX", "H7vLdyxHi23Xz7hDsAevGruVAWxsFP");
            IAcsClient           client  = new DefaultAcsClient(profile);
            SingleSendSmsRequest request = new SingleSendSmsRequest();

            try
            {
                request.SignName     = signName;     // "管理控制台中配置的短信签名(状态必须是验证通过)";
                request.TemplateCode = templateCode; //"管理控制台中配置的审核通过的短信模板的模板CODE(状态必须是验证通过)";
                request.RecNum       = recNum;       //"接收号码,多个号码可以逗号分隔";
                request.ParamString  = paramString;  //"短信模板中的变量;数字需要转换为字符串;个人用户每个变量长度必须小于15个字符。";
                SingleSendSmsResponse httpResponse = client.GetAcsResponse(request);
                return("200");
            }
            catch (ServerException ex)
            {
                WriteLogHelper.WriteError(ex);
                throw;
            }
            catch (ClientException ex)
            {
                WriteLogHelper.WriteError(ex);
                throw;
            }
        }
コード例 #4
0
        /// <summary>
        /// 接收消息
        /// </summary>
        /// <param name="queueName"></param>
        /// <param name="delegateHandle"></param>
        public void GetQueueMessage(string queueName, ReceiveActionDelegate delegateHandle)
        {
            using (var connection = _factory.CreateConnection())
                using (var channel = connection.CreateModel())
                {
                    channel.QueueDeclare(queue: queueName,
                                         durable: true,
                                         exclusive: false,
                                         autoDelete: false,
                                         arguments: null);

                    channel.BasicQos(prefetchSize: 0, prefetchCount: 1, global: false);

                    var consumer = new EventingBasicConsumer(channel);

                    consumer.Received += (model, ea) =>
                    {
                        channel.BasicAck(deliveryTag: ea.DeliveryTag, multiple: false);
                        var    body = ea.Body;
                        object objval;
                        objval = CommonHelper.BytesToObject(body);
                        delegateHandle(objval);
                        WriteLogHelper.WriteLogDoc("GetQueueLog", "队列" + queueName + "获取数据成功", "rabbitMqLog");
                    };
                    channel.BasicConsume(queue: queueName,
                                         autoAck: false,
                                         consumer: consumer);
                }
        }
コード例 #5
0
        /// <summary>
        /// 接收消息
        /// </summary>
        /// <param name="exchangeName"></param>
        /// <param name="queueName"></param>
        /// <param name="rootingkey"></param>
        /// <param name="delegateHandle"></param>
        public void GetQueueMessage(string exchangeName, string queueName, string rootingkey, ReceiveActionDelegate delegateHandle)
        {
            using (var connection = _factory.CreateConnection())
                using (var channel = connection.CreateModel())
                {
                    channel.ExchangeDeclare(exchange: exchangeName,
                                            type: "direct");
                    channel.QueueDeclare(queue: queueName,
                                         durable: true,
                                         exclusive: false,
                                         autoDelete: false,
                                         arguments: null);
                    ///绑定交换机队列
                    channel.QueueBind(queue: queueName,
                                      exchange: exchangeName,
                                      routingKey: rootingkey);

                    var consumer = new EventingBasicConsumer(channel);
                    //声明方法
                    consumer.Received += (model, ea) =>
                    {
                        channel.BasicAck(deliveryTag: ea.DeliveryTag, multiple: false);
                        var    body = ea.Body;
                        object objval;
                        objval = CommonHelper.BytesToObject(body);
                        delegateHandle(objval);
                        WriteLogHelper.WriteLogDoc("GetExchangeQueueLog", "交换机:" + exchangeName + "绑定队列:" + queueName + "获取数据成功", "rabbitMqLog");
                    };
                    channel.BasicConsume(queue: queueName,
                                         autoAck: false,
                                         consumer: consumer);
                }
        }
コード例 #6
0
 private void UnZipFile(string zipFilePath, string targetDir)
 {
     try
     {
         ICCEmbedded.SharpZipLib.Zip.FastZipEvents evt = new ICCEmbedded.SharpZipLib.Zip.FastZipEvents();
         ICCEmbedded.SharpZipLib.Zip.FastZip       fz  = new ICCEmbedded.SharpZipLib.Zip.FastZip(evt);
         fz.ExtractZip(zipFilePath, targetDir, "");
     }
     catch (Exception ex)
     {
         WriteLogHelper.WriteLog_client("UnZipFile error", ex);
         MessageBox.Show(ex.Message);
     }
 }
コード例 #7
0
 /// <summary>
 /// 开始下载更新的zip
 /// </summary>
 private void DownloadUpdateFile()
 {
     try
     {
         string url    = Constants.RemoteUrl_zip;
         var    client = new System.Net.WebClient();
         client.DownloadProgressChanged += (sender, e) =>
         {
             UpdateProcess(e.BytesReceived, e.TotalBytesToReceive);
         };
         client.DownloadDataCompleted += client_DownloadDataCompleted_File;
         client.DownloadDataAsync(new Uri(url));
         SetButtonState();
     }
     catch (Exception ex)
     {
         WriteLogHelper.WriteLog_client("DownloadUpdateFile error", ex);
         MessageBox.Show(ex.Message);
     }
 }
コード例 #8
0
        /// <summary>
        /// 创建消息
        /// </summary>
        /// <param name="queueName"></param>
        /// <param name="obj"></param>
        public void CreateExchangeMessage(string exchangename, string rootingkey, object obj)
        {
            using (var connection = _factory.CreateConnection())
                using (var channel = connection.CreateModel())
                {
                    channel.ExchangeDeclare(exchange: exchangename,
                                            type: "direct");

                    var body = CommonHelper.ObjectToBytes(obj);

                    IBasicProperties props = channel.CreateBasicProperties();
                    props.ContentType  = "text/plain";
                    props.DeliveryMode = 2;

                    channel.BasicPublish(exchange: exchangename,
                                         routingKey: rootingkey,
                                         basicProperties: props,
                                         body: body);
                    WriteLogHelper.WriteLogDoc("CreateExchangeQueueLog", "创建交换机" + exchangename + "加了数据", "rabbitMqLog");
                }
        }
コード例 #9
0
        /// <summary>
        /// 验证签名
        /// </summary>
        /// <param name="content">需要验证的内容</param>
        /// <param name="signedString">签名结果</param>
        /// <param name="publicKey">公钥</param>
        /// <param name="input_charset">编码格式</param>
        /// <returns></returns>
        public static bool Verify(string content, string signedString, string publicKey, string input_charset)
        {
            try
            {
                bool result = false;

                Encoding                 code    = Encoding.GetEncoding(input_charset);
                byte[]                   Data    = code.GetBytes(content);
                byte[]                   data    = Convert.FromBase64String(signedString);
                RSAParameters            paraPub = ConvertFromPublicKey(publicKey);
                RSACryptoServiceProvider rsaPub  = new RSACryptoServiceProvider();
                rsaPub.ImportParameters(paraPub);

                SHA1 sh = new SHA1CryptoServiceProvider();
                result = rsaPub.VerifyData(Data, sh, data);
                return(result);
            }
            catch (System.Exception ex)
            {
                WriteLogHelper.WriteError(ex);
                throw ex;
            }
        }
コード例 #10
0
 private static RSACryptoServiceProvider LoadCertificateFile(string filename)
 {
     using (System.IO.FileStream fs = System.IO.File.OpenRead(filename))
     {
         byte[] data = new byte[fs.Length];
         byte[] res  = null;
         fs.Read(data, 0, data.Length);
         if (data[0] != 0x30)
         {
             res = GetPem("RSA PRIVATE KEY", data);
         }
         try
         {
             RSACryptoServiceProvider rsa = DecodeRSAPrivateKey(res);
             return(rsa);
         }
         catch (Exception ex)
         {
             WriteLogHelper.WriteError(ex);
             throw ex;
         }
     }
 }
コード例 #11
0
        /// <summary>
        /// 创建消息
        /// </summary>
        /// <param name="queueName"></param>
        /// <param name="obj"></param>
        public void CreateQueueMessage(string queueName, object obj)
        {
            using (var connection = _factory.CreateConnection())
                using (var channel = connection.CreateModel())
                {
                    channel.QueueDeclare(queue: queueName,
                                         durable: true,
                                         exclusive: false,
                                         autoDelete: false,
                                         arguments: null);


                    var body = CommonHelper.ObjectToBytes(obj);

                    var properties = channel.CreateBasicProperties();
                    properties.Persistent = true;

                    channel.BasicPublish(exchange: "",
                                         routingKey: queueName,
                                         basicProperties: properties,
                                         body: body);
                    WriteLogHelper.WriteLogDoc("CreateQueueLog", "队列" + queueName + "加了数据", "rabbitMqLog");
                }
        }
コード例 #12
0
        private static RSACryptoServiceProvider DecodeRSAPrivateKey(byte[] privkey)
        {
            byte[] MODULUS, E, D, P, Q, DP, DQ, IQ;

            // ---------  Set up stream to decode the asn.1 encoded RSA private key  ------
            MemoryStream mem      = new MemoryStream(privkey);
            BinaryReader binr     = new BinaryReader(mem); //wrap Memory Stream with BinaryReader for easy reading
            byte         bt       = 0;
            ushort       twobytes = 0;
            int          elems    = 0;

            try
            {
                twobytes = binr.ReadUInt16();
                if (twobytes == 0x8130) //data read as little endian order (actual data order for Sequence is 30 81)
                {
                    binr.ReadByte();    //advance 1 byte
                }
                else if (twobytes == 0x8230)
                {
                    binr.ReadInt16();   //advance 2 bytes
                }
                else
                {
                    return(null);
                }

                twobytes = binr.ReadUInt16();
                if (twobytes != 0x0102) //version number
                {
                    return(null);
                }
                bt = binr.ReadByte();
                if (bt != 0x00)
                {
                    return(null);
                }


                //------  all private key components are Integer sequences ----
                elems   = GetIntegerSize(binr);
                MODULUS = binr.ReadBytes(elems);

                elems = GetIntegerSize(binr);
                E     = binr.ReadBytes(elems);

                elems = GetIntegerSize(binr);
                D     = binr.ReadBytes(elems);

                elems = GetIntegerSize(binr);
                P     = binr.ReadBytes(elems);

                elems = GetIntegerSize(binr);
                Q     = binr.ReadBytes(elems);

                elems = GetIntegerSize(binr);
                DP    = binr.ReadBytes(elems);

                elems = GetIntegerSize(binr);
                DQ    = binr.ReadBytes(elems);

                elems = GetIntegerSize(binr);
                IQ    = binr.ReadBytes(elems);

                // ------- create RSACryptoServiceProvider instance and initialize with public key -----
                RSACryptoServiceProvider RSA       = new RSACryptoServiceProvider();
                RSAParameters            RSAparams = new RSAParameters();
                RSAparams.Modulus  = MODULUS;
                RSAparams.Exponent = E;
                RSAparams.D        = D;
                RSAparams.P        = P;
                RSAparams.Q        = Q;
                RSAparams.DP       = DP;
                RSAparams.DQ       = DQ;
                RSAparams.InverseQ = IQ;
                RSA.ImportParameters(RSAparams);
                return(RSA);
            }
            catch (Exception ex)
            {
                WriteLogHelper.WriteError(ex);
                throw ex;
            }
            finally { binr.Close(); }
        }
コード例 #13
0
        private static RSACryptoServiceProvider DecodePrivateKeyInfo(byte[] pkcs8)
        {
            byte[] SeqOID = { 0x30, 0x0D, 0x06, 0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x01, 0x05, 0x00 };
            byte[] seq    = new byte[15];

            MemoryStream mem       = new MemoryStream(pkcs8);
            int          lenstream = (int)mem.Length;
            BinaryReader binr      = new BinaryReader(mem); //wrap Memory Stream with BinaryReader for easy reading
            byte         bt        = 0;
            ushort       twobytes  = 0;

            try
            {
                twobytes = binr.ReadUInt16();
                if (twobytes == 0x8130) //data read as little endian order (actual data order for Sequence is 30 81)
                {
                    binr.ReadByte();    //advance 1 byte
                }
                else if (twobytes == 0x8230)
                {
                    binr.ReadInt16();   //advance 2 bytes
                }
                else
                {
                    return(null);
                }


                bt = binr.ReadByte();
                if (bt != 0x02)
                {
                    return(null);
                }

                twobytes = binr.ReadUInt16();

                if (twobytes != 0x0001)
                {
                    return(null);
                }

                seq = binr.ReadBytes(15);               //read the Sequence OID
                if (!CompareBytearrays(seq, SeqOID))    //make sure Sequence for OID is correct
                {
                    return(null);
                }

                bt = binr.ReadByte();
                if (bt != 0x04) //expect an Octet string
                {
                    return(null);
                }

                bt = binr.ReadByte();           //read next byte, or next 2 bytes is  0x81 or 0x82; otherwise bt is the byte count
                if (bt == 0x81)
                {
                    binr.ReadByte();
                }
                else
                if (bt == 0x82)
                {
                    binr.ReadUInt16();
                }
                //------ at this stage, the remaining sequence should be the RSA private key

                byte[] rsaprivkey = binr.ReadBytes((int)(lenstream - mem.Position));
                RSACryptoServiceProvider rsacsp = DecodeRSAPrivateKey(rsaprivkey);
                return(rsacsp);
            }

            catch (Exception ex)
            {
                WriteLogHelper.WriteError(ex);
                throw ex;
            }

            finally { binr.Close(); }
        }