npm 有两个代理设置，一个是 http 代理，一个是 https 代理。
在命令行设置代理服务器。
1 2 3 4 5 6 | #获取 http 请求的代理设置 npm config get proxy npm config set proxy="http://127.0.0.1:1080" #获取 https 请求的代理设置 npm config get https-proxy npm config set https-proxy="http://127.0.0.1:1080" |
代理服务器可以使用小灰机（小灰机同时支持 socks 代理和 http 代理）
因为众所周知的原因，在国内使用 NuGet 时会经常无法下载包，严重影响工作效率，下面说一下如何给 NuGet 设置代理。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 | <?xml version="1.0" encoding="utf-8"?> <configuration> <config> <add key="http_proxy" value="http://127.0.0.1:1080" /> </config> <packageSources> <add key="nuget.org" value="https://api.nuget.org/v3/index.json" protocolVersion="3" /> <add key="Microsoft Visual Studio Offline Packages" value="C:\Program Files (x86)\Microsoft SDKs\NuGetPackages\" /> </packageSources> <packageRestore> <add key="enabled" value="True" /> <add key="automatic" value="True" /> </packageRestore> <bindingRedirects> <add key="skip" value="False" /> </bindingRedirects> <packageManagement> <add key="format" value="0" /> <add key="disabled" value="False" /> </packageManagement> <disabledPackageSources> <add key="Microsoft Visual Studio Offline Packages" value="true" /> </disabledPackageSources> </configuration> |
代理服务器可以是任何 http 代理，也可以用小灰机代理（小灰机本身即是 socks 代理也是 http 代理）。
当前最新 .net core 版本为 2.1
打开 .net core 下载页面，https://www.microsoft.com/net/download/linux ，页面包含 .net core sdk 及 .net core runtime 两个安装包。
如果需要在 linux 上进行开发，要安装 .net core sdk 版本，不需要开发推荐安装 .net core runtime 版本。
点击 install .NET Core 2.1 Runtime ，进入下载页面,在下拉框中选择 Centos。
按提示输入以下命令
1 2 3 4 5 6 7 | rpm -Uvh https://packages.microsoft.com/config/rhel/7/packages-microsoft-prod.rpm #如果需要同时支持运行 asp.net core 和 .net core app ,则运行这条命令 yum install aspnetcore-runtime-2.1 #如果只要需运行 .net core app, 不需要 asp.net core ,则运行这条命令 yum install dotnet-runtime-2.1 |
安装完成后运行 dotnet –info 查看版本信息
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 | <?xml version="1.0" encoding="utf-8" ?> <configuration> <configSections> <section name="log4net" type="log4net.Config.Log4NetConfigurationSectionHandler, log4net" /> </configSections> <log4net> <appender name="RollingLogFileAppender" type="log4net.Appender.RollingFileAppender"> <File value="Log\" /> <!--是否是向文件中追加日志--> <AppendToFile value="true" /> <!--每个文件的大小--> <MaximumFileSize value="1MB"/> <!--log文件数--> <MaxSizeRollBackups value="10" /> <!--日志文件名是否是固定不变的--> <StaticLogFileName value="false" /> <!--日志文件名格式为:yyyy-MM-dd.log--> <DatePattern value="yyyy\\MM\\dd\\yyyy-MM-dd'.log'" /> <!--日志根据日期滚动--> <RollingStyle value="Date" /> <layout type="log4net.Layout.PatternLayout"> <ConversionPattern value="%date %logger [%thread] %level %message%newline" /> </layout> </appender> <root> <!--(高) OFF > FATAL > ERROR > WARN > INFO > DEBUG > ALL (低) --> <level value="all" /> <appender-ref ref="RollingLogFileAppender" /> </root> </log4net> </configuration> |
配置好后在程序集 AssemblyInfo.cs 中加入
1 | [assembly: log4net.Config.XmlConfigurator( ConfigFile = "log4net.config", Watch = true )] |
或者用代码初始化
1 2 3 4 5 6 7 8 9 10 11 12 13 | private void InitLog4net() { var logCfg = new FileInfo(AppDomain.CurrentDomain.BaseDirectory + "log4net.config"); XmlConfigurator.ConfigureAndWatch(logCfg); //修改日志路径 var repository = LogManager.GetRepository(); var appenders = repository.GetAppenders(); var targetApder = appenders.First() as RollingFileAppender; targetApder.File = string.IsNullOrWhiteSpace(Settings.Default.LogPath) ? Path.Combine( Environment.CurrentDirectory,"log.txt") : Settings.Default.LogPath; targetApder.ActivateOptions(); this.log = LogManager.GetLogger("mainlog"); } |
使用 MySql EF6 DBfirst 生成模型时经常会遇到EF6模式无法选择的情况 究其原因, 还是因为没有正确的使用 Connector/Net. 下面说一下使用方法. 使用 MySql DBFirst 前先确保安装了 MySql, MySQL for Visual Studio, Connector/Net 注意: MySQL for Visual Studio, Connector/Net 版本要对应 MySql 版本.
1 | Install-Package EntityFramework |
在项目的”引用”上点右键添加dll引用. 选择扩展程序集, 勾选 MySql.Data.Entity for EF6 , 注意提示框中的版本, 一个是4.0, 一个是 4.5. 这个dll 是安装 Connector/Net 后才有的.
注意: 用 nuget 安装 MySql.Data.Entity 也会自动引用 MySql.Data.Entity.EF6.dll. 但是这个 dll 在生成 edmx 时会出错. 所以才要像上面一样从扩展中引用 dll
添加一行 provider
1 | <provider invariantName="MySql.Data.MySqlClient" type="MySql.Data.MySqlClient.MySqlProviderServices, MySql.Data.Entity.EF6" /> |
添加完如下所示
1 2 3 4 5 6 7 8 9 10 11 | <entityFramework> <defaultConnectionFactory type="System.Data.Entity.Infrastructure.LocalDbConnectionFactory, EntityFramework"> <parameters> <parameter value="v12.0" /> </parameters> </defaultConnectionFactory> <providers> <provider invariantName="System.Data.SqlClient" type="System.Data.Entity.SqlServer.SqlProviderServices, EntityFramework.SqlServer" /> <provider invariantName="MySql.Data.MySqlClient" type="MySql.Data.MySqlClient.MySqlProviderServices, MySql.Data.Entity.EF6" /> </providers> </entityFramework> |
重新生成一下项目, 到这里问题就已经解决了. 下面是效果.
如果数据源不是 MySql, 点更新, 修改为MySql.如果没有MySql Database , 说明 Connector/Net 没有安装或安装不正确. 重新安装.这里可以正确显示了.
首先准备 VS 安装介质, 如 .iso 文件, 加载到虚拟光驱中.
再以管理员权限运行 CMD, 转到 虚拟光驱的盘符, 输入以下命令
1 | vs_community.exe /uninstall /force |
我的是社区版本, 如果是专业版或企业版, 只要将 vs_community 替换为对应介质中的程序名即可.
本文转自 http://www.blogbus.com/softone-logs/105678346.html
作者：Eckel Chung blog地址：http://softone.blogbus.com/ 转载请保留
—————————————————————————
（1）前言
和网上大量的讨论如何制作数字签名和验证数字签名的文章本同，本文使用微软自带的API进行PE文件数字签名有效性的验证，使用语言C#。
我们可以在windows系统下直接右键查看某个PE文件数字签名的有效性，如下图：
这让我们想到，微软必然自带了对PE文件数字签名的验证办法，经过查找资料，确定其来自下图所示的dll文件里的WinVerifyTrust函数。
该函数在C#里的调用原型如下：
1 2 | [DllImport("wintrust.dll", PreserveSig = true, SetLastError = false)] private static extern uint WinVerifyTrust(IntPtr hWnd, IntPtr pgActionID, IntPtr pWinTrustData); |
关于这个函数的使用，可以查看MSDN上的说明 。
(2) 构建将要用到的数据结构
根据微软官方材料，我们在使用这个函数前还得先准备几个数据结构：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 | using System; using System.Runtime.InteropServices; namespace VerifyDigitalSignature { public enum AllocMethod { HGlobal, CoTaskMem } public enum UnionChoice { File = 1, Catalog, Blob, Signer, Cert } public enum UiChoice { All = 1, NoUI, NoBad, NoGood } public enum RevocationCheckFlags { None = 0, WholeChain } public enum StateAction { Ignore = 0, Verify, Close, AutoCache, AutoCacheFlush } public enum TrustProviderFlags { UseIE4Trust = 1, NoIE4Chain = 2, NoPolicyUsage = 4, RevocationCheckNone = 16, RevocationCheckEndCert = 32, RevocationCheckChain = 64, RecovationCheckChainExcludeRoot = 128, Safer = 256, HashOnly = 512, UseDefaultOSVerCheck = 1024, LifetimeSigning = 2048 } public enum UIContext { Execute = 0, Install } #region UnmanagedPointer class internal sealed class UnmanagedPointer : IDisposable { private IntPtr m_ptr; private AllocMethod m_meth; internal UnmanagedPointer( IntPtr ptr, AllocMethod method ) { m_meth = method; m_ptr = ptr; } ~UnmanagedPointer() { Dispose( false ); } #region IDisposable Members private void Dispose( bool disposing ) { if ( m_ptr != IntPtr.Zero ) { if ( m_meth == AllocMethod.HGlobal ) { Marshal.FreeHGlobal( m_ptr ); } else if ( m_meth == AllocMethod.CoTaskMem ) { Marshal.FreeCoTaskMem( m_ptr ); } m_ptr = IntPtr.Zero; } if ( disposing ) { GC.SuppressFinalize( this ); } } public void Dispose() { Dispose( true ); } #endregion public static implicit operator IntPtr( UnmanagedPointer ptr ) { return ptr.m_ptr; } } #endregion internal struct WINTRUST_FILE_INFO : IDisposable { public WINTRUST_FILE_INFO( string fileName, Guid subject ) { cbStruct = (uint)Marshal.SizeOf( typeof( WINTRUST_FILE_INFO ) ); pcwszFilePath = fileName; if ( subject != Guid.Empty ) { pgKnownSubject = Marshal.AllocHGlobal( Marshal.SizeOf( typeof( Guid ) ) ); Marshal.StructureToPtr( subject, pgKnownSubject, true ); } else { pgKnownSubject = IntPtr.Zero; } hFile = IntPtr.Zero; } public uint cbStruct; [MarshalAs( UnmanagedType.LPTStr )] public string pcwszFilePath; public IntPtr hFile; public IntPtr pgKnownSubject; #region IDisposable Members public void Dispose() { Dispose( true ); } private void Dispose( bool disposing ) { if ( pgKnownSubject != IntPtr.Zero ) { Marshal.DestroyStructure( this.pgKnownSubject, typeof( Guid ) ); Marshal.FreeHGlobal( this.pgKnownSubject ); } } #endregion } [StructLayout( LayoutKind.Sequential )] internal struct WINTRUST_DATA : IDisposable { public WINTRUST_DATA( WINTRUST_FILE_INFO fileInfo ) { this.cbStruct = (uint)Marshal.SizeOf( typeof( WINTRUST_DATA ) ); pInfoStruct = Marshal.AllocHGlobal( Marshal.SizeOf( typeof( WINTRUST_FILE_INFO ) ) ); Marshal.StructureToPtr( fileInfo, pInfoStruct, true ); this.dwUnionChoice = UnionChoice.File; pPolicyCallbackData = IntPtr.Zero; pSIPCallbackData = IntPtr.Zero; dwUIChoice = UiChoice.NoUI; fdwRevocationChecks = RevocationCheckFlags.None; dwStateAction = StateAction.Ignore; hWVTStateData = IntPtr.Zero; pwszURLReference = IntPtr.Zero; dwProvFlags = TrustProviderFlags.Safer; dwUIContext = UIContext.Execute; } public uint cbStruct; public IntPtr pPolicyCallbackData; public IntPtr pSIPCallbackData; public UiChoice dwUIChoice; public RevocationCheckFlags fdwRevocationChecks; public UnionChoice dwUnionChoice; public IntPtr pInfoStruct; public StateAction dwStateAction; public IntPtr hWVTStateData; private IntPtr pwszURLReference; public TrustProviderFlags dwProvFlags; public UIContext dwUIContext; #region IDisposable Members public void Dispose() { Dispose( true ); } private void Dispose( bool disposing ) { if ( dwUnionChoice == UnionChoice.File ) { //WINTRUST_FILE_INFO info = new WINTRUST_FILE_INFO(); //Marshal.PtrToStructure(pInfoStruct, info); //info.Dispose(); Marshal.DestroyStructure( pInfoStruct, typeof( WINTRUST_FILE_INFO ) ); } Marshal.FreeHGlobal( pInfoStruct ); } #endregion } } |
（3）构建我们的验证类
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 | using System; using System.Collections.Generic; using System.Runtime.InteropServices; using Microsoft.Win32; namespace VerifyDigitalSignature { public class Authentication { [DllImport( "wintrust.dll", PreserveSig = true, SetLastError = false )] private static extern uint WinVerifyTrust( IntPtr hWnd, IntPtr pgActionID, IntPtr pWinTrustData ); private static List<Guid> GetTrustGuid() { //HKEY_LOCAL_MACHINESOFTWAREMicrosoftCryptographyProvidersTrustInitialization List<Guid> trustGuids = new List<Guid>(); RegistryKey hklm = Registry.LocalMachine; RegistryKey initialization = hklm.OpenSubKey( @"SOFTWAREMicrosoftCryptographyProvidersTrustInitialization" ); string[] guidNames = initialization.GetSubKeyNames(); foreach ( string guidName in guidNames ) { trustGuids.Add( new Guid( guidName ) ); } return trustGuids; } public static uint CSWinVerifyTrust( string fileName ) { uint result = 1516356; try { List<Guid> trustGuids = GetTrustGuid(); foreach ( Guid guid in trustGuids ) { Guid wintrust_action_generic_verify_v2 = guid; WINTRUST_FILE_INFO fileInfo = new WINTRUST_FILE_INFO( fileName, Guid.Empty ); WINTRUST_DATA data = new WINTRUST_DATA( fileInfo ); UnmanagedPointer guidPtr = new UnmanagedPointer( Marshal.AllocHGlobal( Marshal.SizeOf( typeof( Guid ) ) ), AllocMethod.HGlobal ); UnmanagedPointer wvtDataPtr = new UnmanagedPointer( Marshal.AllocHGlobal( Marshal.SizeOf( typeof( WINTRUST_DATA ) ) ), AllocMethod.HGlobal ); IntPtr pGuid = guidPtr; IntPtr pData = wvtDataPtr; Marshal.StructureToPtr( wintrust_action_generic_verify_v2, pGuid, true ); Marshal.StructureToPtr( data, pData, true ); result = WinVerifyTrust( IntPtr.Zero, pGuid, pData ); if ( result == 0 ) { break; } } } catch ( Exception ex ) { throw new Exception( "VerifyDigitalSignature error.", ex ); } return result; } } } |
注意这里，WinVerifyTrust的返回值有多种，0表示数字签名各项指标都是正常的，其他代码我们下一部分再来讨论。
实测通过：
1 | REGEX:(?insx)/[^?/]*.(css|ico|jpg|png|gif|bmp|wav)(?.*)?$ |
此表达式表示过滤掉 url 中包括 css, ico, jpg 等后缀的请求.
下面的代码实现了基本的 http ,https 请求, 支持 gzip 解压, 分块传输.
经本人多次试验, 得出如下结论:
如果仅用 Socket 获取文本类型的内容, 且不考虑分块传输的情况, 那么 Socket 方式可比 HttpWebRequest 方式效率高 30%-40%.
如果考虑更多因素,需要做更多处理, 所以多数时候效率不如 HttpWebRequest, 当然与我写的代码效率有很大关系.
欢迎共同探讨技术问题,提供建议, 请留言,我会尽快回复.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 | /* Name: Socket 实现 http 协议全功能版 * Version: v0.6 * Description: 此版本实现了 http 及 https 的 get 或 post 访问, 自动处理301,302跳转, 支持 gzip 解压, 分块传输. * 支持的操作: 获取文本,图片,文件形式的内容. * 使用方法: new HttpWebSocket(); 调用实例的 Get.... 方法. * 声明: 本代码仅做技术探讨,可任意转载,请勿用于商业用途. * 本人博客: http://blog.itnmg.net http://www.cnblogs.com/lhg-net * 创建日期: 2013-01-15 * 修订日期: 2013-06-03 */ using System; using System.Collections.Generic; using System.Net; using System.Net.Sockets; using System.Net.Security; using System.Text; using System.Text.RegularExpressions; using System.IO; using System.IO.Compression; using System.Web; using System.Drawing; using System.Security.Cryptography.X509Certificates; namespace ExtLibrary.Net { class HttpWebSocket { /// <summary> /// 获取或设置请求与回应的超时时间,默认3秒. /// </summary> public int TimeOut { get; set; } /// <summary> /// 获取或设置请求cookie /// </summary> public List<string> Cookies { get; set; } /// <summary> /// 获取请求返回的 HTTP 头部内容 /// </summary> public HttpHeader HttpHeaders { get; internal set; } /// <summary> /// 获取或设置错误信息分隔符 /// </summary> private string ErrorMessageSeparate; public HttpWebSocket() { this.TimeOut = 3; this.Cookies = new List<string>(); this.ErrorMessageSeparate = ";;"; this.HttpHeaders = new HttpHeader(); } /// <summary> /// get或post方式请求一个 http 或 https 地址.使用 Socket 方式 /// </summary> /// <param name="url">请求绝对地址</param> /// <param name="referer">请求来源地址,可为空</param> /// <param name="postData">post请求参数. 设置空值为get方式请求</param> /// <returns>返回图像</returns> public Image GetImageUseSocket( string url, string referer, string postData = null ) { Image result = null; MemoryStream ms = this.GetSocketResult( url, referer, postData ); try { if ( ms != null ) { result = Image.FromStream( ms ); } } catch ( Exception e ) { string ss = e.Message; } return result; } /// <summary> /// get或post方式请求一个 http 或 https 地址.使用 Socket 方式 /// </summary> /// <param name="url">请求绝对地址</param> /// <param name="postData">post请求参数. 设置空值为get方式请求</param> /// <returns>返回 html 内容,如果发生异常将返回上次http状态码及异常信息</returns> public string GetHtmlUseSocket( string url, string postData = null ) { return this.GetHtmlUseSocket( url, null, postData ); } /// <summary> /// get或post方式请求一个 http 或 https 地址.使用 Socket 方式 /// </summary> /// <param name="url">请求绝对地址</param> /// <param name="referer">请求来源地址,可为空</param> /// <param name="postData">post请求参数. 设置空值为get方式请求</param> /// <returns>返回 html 内容,如果发生异常将返回上次http状态码及异常信息</returns> public string GetHtmlUseSocket( string url, string referer, string postData = null ) { string result = string.Empty; try { MemoryStream ms = this.GetSocketResult( url, referer, postData ); if ( ms != null ) { result = Encoding.GetEncoding( string.IsNullOrWhiteSpace( this.HttpHeaders.Charset ) ? "UTF-8" : this.HttpHeaders.Charset ).GetString( ms.ToArray() ); } } catch ( SocketException se ) { result = this.HttpHeaders.ResponseStatusCode + this.ErrorMessageSeparate + se.ErrorCode.ToString() + this.ErrorMessageSeparate + se.SocketErrorCode.ToString( "G" ) + this.ErrorMessageSeparate + se.Message; } catch ( Exception e ) { result = this.HttpHeaders.ResponseStatusCode + this.ErrorMessageSeparate + e.Message; } return result; } /// <summary> /// get或post方式请求一个 http 或 https 地址. /// </summary> /// <param name="url">请求绝对地址</param> /// <param name="referer">请求来源地址,可为空</param> /// <param name="postData">post请求参数. 设置空值为get方式请求</param> /// <returns>返回的已解压的数据内容</returns> private MemoryStream GetSocketResult( string url, string referer, string postData ) { if ( string.IsNullOrWhiteSpace( url ) ) { throw new UriFormatException( "'Url' cannot be empty." ); } MemoryStream result = null; Uri uri = new Uri( url ); if ( uri.Scheme == "http" ) { result = this.GetHttpResult( uri, referer, postData ); } else if ( uri.Scheme == "https" ) { result = this.GetSslResult( uri, referer, postData ); } else { throw new ArgumentException( "url must start with HTTP or HTTPS.", "url" ); } if ( !string.IsNullOrWhiteSpace( this.HttpHeaders.Location ) ) { result = GetSocketResult( this.HttpHeaders.Location, uri.AbsoluteUri, null ); } else { result = unGzip( result ); } return result; } /// <summary> /// get或post方式请求一个 http 地址. /// </summary> /// <param name="uri">请求绝对地址</param> /// <param name="referer">请求来源地址,可为空</param> /// <param name="postData">post请求参数. 设置空值为get方式请求</param> /// <param name="headText">输出包含头部内容的StringBuilder</param> /// <returns>返回未解压的数据流</returns> private MemoryStream GetHttpResult( Uri uri, string referer, string postData ) { MemoryStream result = new MemoryStream( 10240 ); Socket HttpSocket = new Socket( AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp ); HttpSocket.SendTimeout = this.TimeOut * 1000; HttpSocket.ReceiveTimeout = this.TimeOut * 1000; try { byte[] send = GetSendHeaders( uri, referer, postData ); HttpSocket.Connect( uri.Host, uri.Port ); if ( HttpSocket.Connected ) { HttpSocket.Send( send, SocketFlags.None ); this.ProcessData( HttpSocket, ref result ); } result.Flush(); } finally { HttpSocket.Shutdown( SocketShutdown.Both ); HttpSocket.Close(); } result.Seek( 0, SeekOrigin.Begin ); return result; } /// <summary> /// get或post方式请求一个 https 地址. /// </summary> /// <param name="uri">请求绝对地址</param> /// <param name="referer">请求来源地址,可为空</param> /// <param name="postData">post请求参数. 设置空值为get方式请求</param> /// <param name="headText">输出包含头部内容的StringBuilder</param> /// <returns>返回未解压的数据流</returns> private MemoryStream GetSslResult( Uri uri, string referer, string postData ) { MemoryStream result = new MemoryStream( 10240 ); StringBuilder sb = new StringBuilder( 1024 ); byte[] send = GetSendHeaders( uri, referer, postData ); TcpClient client = new TcpClient( uri.Host, uri.Port ); try { SslStream sslStream = new SslStream( client.GetStream(), true , new RemoteCertificateValidationCallback( ( sender, certificate, chain, sslPolicyErrors ) => { return sslPolicyErrors == SslPolicyErrors.None; } ), null ); sslStream.ReadTimeout = this.TimeOut * 1000; sslStream.WriteTimeout = this.TimeOut * 1000; X509Store store = new X509Store( StoreName.My ); sslStream.AuthenticateAsClient( uri.Host, store.Certificates, System.Security.Authentication.SslProtocols.Default, false ); if ( sslStream.IsAuthenticated ) { sslStream.Write( send, 0, send.Length ); sslStream.Flush(); this.ProcessData( sslStream, ref result ); } result.Flush(); } finally { client.Close(); } result.Seek( 0, SeekOrigin.Begin ); return result; } /// <summary> /// 返回请求的头部内容 /// </summary> /// <param name="uri">请求绝对地址</param> /// <param name="referer">请求来源地址,可为空</param> /// <param name="postData">post请求参数. 设置空值为get方式请求</param> /// <returns>请求头部数据</returns> private byte[] GetSendHeaders( Uri uri, string referer, string postData ) { string sendString = @"{0} {1} HTTP/1.1 Accept: text/html, application/xhtml+xml, */* Referer: {2} Accept-Language: zh-CN User-Agent: Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; WOW64; Trident/5.0) Accept-Encoding: gzip, deflate Host: {3} Connection: Keep-Alive Cache-Control: no-cache "; sendString = string.Format( sendString, string.IsNullOrWhiteSpace( postData ) ? "GET" : "POST", uri.PathAndQuery , string.IsNullOrWhiteSpace( referer ) ? uri.AbsoluteUri : referer, uri.Host ); if ( this.Cookies != null && this.Cookies.Count > 0 ) { sendString += string.Format( "Cookie: {0}rn", string.Join( "; ", this.Cookies.ToArray() ) ); } if ( string.IsNullOrWhiteSpace( postData ) ) { sendString += "rn"; } else { int dlength = Encoding.UTF8.GetBytes( postData ).Length; sendString += string.Format( @"Content-Type: application/x-www-form-urlencoded Content-Length: {0} {1} ", postData.Length, postData ); } return Encoding.UTF8.GetBytes( sendString ); ; } /// <summary> /// 设置此类的字段 /// </summary> /// <param name="headText">头部文本</param> private void SetThisHeaders( string headText ) { if ( string.IsNullOrWhiteSpace( headText ) ) { throw new ArgumentNullException( "'WithHeadersText' cannot be empty." ); } //Match m = Regex.Match( withHeadersText,@".*(?=rnrn)", RegexOptions.Singleline | RegexOptions.IgnoreCase ); //if ( m == null || string.IsNullOrWhiteSpace( m.Value ) ) //{ // throw new HttpParseException( "'SetThisHeaders' method has bug." ); //} string[] headers = headText.Split( new string[] { "rn" }, StringSplitOptions.RemoveEmptyEntries ); if ( headers == null || headers.Length == 0 ) { throw new ArgumentException( "'WithHeadersText' param format error." ); } this.HttpHeaders = new HttpHeader(); foreach ( string head in headers ) { if ( head.StartsWith( "HTTP", StringComparison.OrdinalIgnoreCase ) ) { string[] ts = head.Split( ' ' ); if ( ts.Length > 1 ) { this.HttpHeaders.ResponseStatusCode = ts[1]; } } else if ( head.StartsWith( "Set-Cookie:", StringComparison.OrdinalIgnoreCase ) ) { this.Cookies = this.Cookies ?? new List<string>(); string tCookie = head.Substring( 11, head.IndexOf( ";" ) < 0 ? head.Length - 11 : head.IndexOf( ";" ) - 10 ).Trim(); if ( !this.Cookies.Exists( f => f.Split( '=' )[0] == tCookie.Split( '=' )[0] ) ) { this.Cookies.Add( tCookie ); } } else if ( head.StartsWith( "Location:", StringComparison.OrdinalIgnoreCase ) ) { this.HttpHeaders.Location = head.Substring( 9 ).Trim(); } else if ( head.StartsWith( "Content-Encoding:", StringComparison.OrdinalIgnoreCase ) ) { if ( head.IndexOf( "gzip", StringComparison.OrdinalIgnoreCase ) >= 0 ) { this.HttpHeaders.IsGzip = true; } } else if ( head.StartsWith( "Content-Type:", StringComparison.OrdinalIgnoreCase ) ) { string[] types = head.Substring( 13 ).Split( new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries ); foreach ( string t in types ) { if ( t.IndexOf( "charset=", StringComparison.OrdinalIgnoreCase ) >= 0 ) { this.HttpHeaders.Charset = t.Trim().Substring( 8 ); } else if ( t.IndexOf( '/' ) >= 0 ) { this.HttpHeaders.ContentType = t.Trim(); } } } else if ( head.StartsWith( "Content-Length:", StringComparison.OrdinalIgnoreCase ) ) { this.HttpHeaders.ContentLength = long.Parse( head.Substring( 15 ).Trim() ); } else if ( head.StartsWith( "Transfer-Encoding:", StringComparison.OrdinalIgnoreCase ) && head.EndsWith( "chunked", StringComparison.OrdinalIgnoreCase ) ) { this.HttpHeaders.IsChunk = true; } } } /// <summary> /// 解压数据流 /// </summary> /// <param name="data">数据流, 压缩或未压缩的.</param> /// <returns>返回解压缩的数据流</returns> private MemoryStream unGzip( MemoryStream data ) { if ( data == null ) { throw new ArgumentNullException( "data cannot be null.", "data" ); } data.Seek( 0, SeekOrigin.Begin ); MemoryStream result = data; if ( this.HttpHeaders.IsGzip ) { GZipStream gs = new GZipStream( data, CompressionMode.Decompress ); result = new MemoryStream( 1024 ); try { byte[] buffer = new byte[1024]; int length = -1; do { length = gs.Read( buffer, 0, buffer.Length ); result.Write( buffer, 0, length ); } while ( length != 0 ); gs.Flush(); result.Flush(); } finally { gs.Close(); } } return result; } /// <summary> /// 处理请求返回的数据. /// </summary> /// <typeparam name="T">数据源类型</typeparam> /// <param name="reader">数据源实例</param> /// <param name="body">保存数据的流</param> private void ProcessData<T>( T reader, ref MemoryStream body ) { byte[] data = new byte[10240]; int bodyStart = -1;//数据部分起始位置 int readLength = 0; bodyStart = GetHeaders( reader, ref data, ref readLength ); if ( bodyStart >= 0 ) { if ( this.HttpHeaders.IsChunk ) { GetChunkData( reader, ref data, ref bodyStart, ref readLength, ref body ); } else { GetBodyData( reader, ref data, bodyStart, readLength, ref body ); } } } /// <summary> /// 取得返回的http头部内容,并设置相关属性. /// </summary> /// <typeparam name="T">数据源类型</typeparam> /// <param name="reader">数据源实例</param> /// <param name="data">待处理的数据</param> /// <param name="readLength">读取的长度</param> /// <returns>数据内容的起始位置,返回-1表示未读完头部内容</returns> private int GetHeaders<T>( T reader, ref byte[] data, ref int readLength ) { int result = -1; StringBuilder sb = new StringBuilder( 1024 ); do { readLength = this.ReadData( reader, ref data ); if ( result < 0 ) { for ( int i = 0; i < data.Length; i++ ) { char c = (char)data[i]; sb.Append( c ); if ( c == 'n' && string.Concat( sb[sb.Length - 4], sb[sb.Length - 3], sb[sb.Length - 2], sb[sb.Length - 1] ).Contains( "rnrn" ) ) { result = i + 1; this.SetThisHeaders( sb.ToString() ); break; } } } if ( result >= 0 ) { break; } } while ( readLength > 0 ); return result; } /// <summary> /// 取得未分块数据的内容 /// </summary> /// <typeparam name="T">数据源类型</typeparam> /// <param name="reader">数据源实例</param> /// <param name="data">已读取未处理的字节数据</param> /// <param name="startIndex">起始位置</param> /// <param name="readLength">读取的长度</param> /// <param name="body">保存块数据的流</param> private void GetBodyData<T>( T reader, ref byte[] data, int startIndex, int readLength, ref MemoryStream body ) { int contentTotal = 0; if ( startIndex < data.Length ) { int count = readLength - startIndex; body.Write( data, startIndex, count ); contentTotal += count; } int tlength = 0; do { tlength = this.ReadData( reader, ref data ); contentTotal += tlength; body.Write( data, 0, tlength ); if ( this.HttpHeaders.ContentLength > 0 && contentTotal >= this.HttpHeaders.ContentLength ) { break; } } while ( tlength > 0 ); } /// <summary> /// 取得分块数据 /// </summary> /// <typeparam name="T">数据源类型</typeparam> /// <param name="reader">Socket实例</param> /// <param name="data">已读取未处理的字节数据</param> /// <param name="startIndex">起始位置</param> /// <param name="readLength">读取的长度</param> /// <param name="body">保存块数据的流</param> private void GetChunkData<T>( T reader, ref byte[] data, ref int startIndex, ref int readLength, ref MemoryStream body ) { int chunkSize = -1;//每个数据块的长度,用于分块数据.当长度为0时,说明读到数据末尾. while ( true ) { chunkSize = this.GetChunkHead( reader, ref data, ref startIndex, ref readLength ); this.GetChunkBody( reader, ref data, ref startIndex, ref readLength, ref body, chunkSize ); if ( chunkSize <= 0 ) { break; } } } /// <summary> /// 取得分块数据的数据长度 /// </summary> /// <typeparam name="T">数据源类型</typeparam> /// <param name="reader">Socket实例</param> /// <param name="data">已读取未处理的字节数据</param> /// <param name="startIndex">起始位置</param> /// <param name="readLength">读取的长度</param> /// <returns>块长度,返回0表示已到末尾.</returns> private int GetChunkHead<T>( T reader, ref byte[] data, ref int startIndex, ref int readLength ) { int chunkSize = -1; List<char> tChars = new List<char>();//用于临时存储块长度字符 if ( startIndex >= data.Length || startIndex >= readLength ) { readLength = this.ReadData( reader, ref data ); startIndex = 0; } do { for ( int i = startIndex; i < readLength; i++ ) { char c = (char)data[i]; if ( c == 'n' ) { try { chunkSize = Convert.ToInt32( new string( tChars.ToArray() ).TrimEnd( 'r' ), 16 ); startIndex = i + 1; } catch ( Exception e ) { throw new Exception( "Maybe exists 'chunk-ext' field.", e ); } break; } tChars.Add( c ); } if ( chunkSize >= 0 ) { break; } startIndex = 0; readLength = this.ReadData( reader, ref data ); } while ( readLength > 0 ); return chunkSize; } /// <summary> /// 取得分块传回的数据内容 /// </summary> /// <typeparam name="T">数据源类型</typeparam> /// <param name="reader">Socket实例</param> /// <param name="data">已读取未处理的字节数据</param> /// <param name="startIndex">起始位置</param> /// <param name="readLength">读取的长度</param> /// <param name="body">保存块数据的流</param> /// <param name="chunkSize">块长度</param> private void GetChunkBody<T>( T reader, ref byte[] data, ref int startIndex, ref int readLength, ref MemoryStream body, int chunkSize ) { if ( chunkSize <= 0 ) { return; } int chunkReadLength = 0;//每个数据块已读取长度 if ( startIndex >= data.Length || startIndex >= readLength ) { readLength = this.ReadData( reader, ref data ); startIndex = 0; } do { int owing = chunkSize - chunkReadLength; int count = Math.Min( readLength - startIndex, owing ); body.Write( data, startIndex, count ); chunkReadLength += count; if ( owing <= count ) { startIndex += count + 2; break; } startIndex = 0; readLength = this.ReadData( reader, ref data ); } while ( readLength > 0 ); } /// <summary> /// 从数据源读取数据 /// </summary> /// <typeparam name="T">数据源类型</typeparam> /// <param name="reader">数据源</param> /// <param name="data">用于存储读取的数据</param> /// <returns>读取的数据长度,无数据为-1</returns> private int ReadData<T>( T reader, ref byte[] data ) { int result = -1; if ( reader is Socket ) { result = (reader as Socket).Receive( data, SocketFlags.None ); } else if ( reader is SslStream ) { result = (reader as SslStream).Read( data, 0, data.Length ); } return result; } } public class HttpHeader { /// <summary> /// 获取请求回应状态码 /// </summary> public string ResponseStatusCode { get; internal set; } /// <summary> /// 获取跳转url /// </summary> public string Location { get; internal set; } /// <summary> /// 获取是否由Gzip压缩 /// </summary> public bool IsGzip { get; internal set; } /// <summary> /// 获取返回的文档类型 /// </summary> public string ContentType { get; internal set; } /// <summary> /// 获取内容使用的字符集 /// </summary> public string Charset { get; internal set; } /// <summary> /// 获取内容长度 /// </summary> public long ContentLength { get; internal set; } /// <summary> /// 获取是否分块传输 /// </summary> public bool IsChunk { get; internal set; } } } |
最近在研究代码签名技术, 花了不少时间, 下面记录一下从了解代码签名到获得一个有效的代码签名证书的过程.
代码签名即软件的所有者使用受全球认可的第三方发放的能证明其真实身份的 “代码签名数字证书” 为其开发的软件添加一个标记, 即所谓的 “签名”, 因而增强了可信度.
耳听为虚, 眼见为实, 有图有真象.
证明软件在发行和传播过程中未经篡改, 增强安全性.
当软件中有涉及到安全方面或底层代码的地方, 如果没有代码签名, 系统会弹出警示框是否要继续安装或执行, 而签名之后的代码便会顺利通过安全检测, 不会弹出警示框.
按照不同的系统和文件类型可以为多种文件进行签名. 比如微软常见的 .exe, .dll, .cab, .msi, .ocx, .sys, .cat, .vbs 等文件类型. Android 系统中的 .apk 文件. Java 中的 .jar 文件等.
代码签名证书: 通过 sn.exe 自制证书或申请免费证书, 稍后重点介绍申请免费证书.
签名工具: .net 中为 SignTool.exe, 已随 Visual Studio 或 Windows SDK 安装.
时间戳服务器: 网络上有很多提供免费时间戳服务的机构, 最著名的有 Symantec 的时间戳服务, 下面列举一些常用的.
http://timestamp.verisign.com/scripts/timstamp.dll
http://timestamp.comodoca.com/authenticode
http://www.startssl.com/timestamp
http://timestamp.wosign.com/timestamp
http://timestamp.globalsign.com/scripts/timstamp.dll
http://www.trustcenter.de/codesigning/timestamp
申请代码签名证书: