home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 1996 December / PCWKCD1296.iso / vjplusb / activex / inetsdk / bin / i386 / readme.txt < prev    next >
Text File  |  1996-06-04  |  9KB  |  221 lines
  1. NOPROXY.REG    Quick setup for INet SDK without a CERN proxy
  2.  
  3. PROXY.REG      Quick setup for INet SDK with a CERN proxy called "proxy"
  4.  
  5. OLECNFG.EXE    Configuration utility for DCOM Beta.
  6.                Requires Windows NT 4.0 ("SUR") Beta 1.
  7.  
  8. MkTypLib.Exe   Unsupported build provided for this SDK.
  9.                The official release will use MIDL.
  10.  
  11. STMTOOL.EXE    Tool for creating .STM files for use in the <OBJECT> tag
  12.                See SPECS\WD-OBJECT.HTM for details.
  13.  
  14. DIANTZ.EXE     CAB-packager tool. See SPECS\CODEDWLD.DOC for details.
  15.  
  16. SHOW SCRIPT ERRORS.REG
  17.                Registry settings to enable reporting of script errors
  18.                in Internet Explorer. By default, the browser displays
  19.                a dialog when it encounters an error parsing or running
  20.                a script on a page. The dialog contains a checkbox 
  21.                (on by default) for disabling the reporting of additonal
  22.                errors on the same  page.    
  23.  
  24. DONT SHOW SCRIPT ERRORS.REG
  25.                Registry settings to disable reporting of script 
  26.                errors in Internet Explorer.
  27.  
  28. ALLOW CODE DOWNLOAD.REG
  29.                Registry settings to enable automatic code download 
  30.                in Internet Explorer (this is the default).
  31.  
  32. DONT ALLOW CODE DOWNLOAD.REG
  33.                Registry settings to disable automatic code download 
  34.                in Internet Explorer.
  35.  
  36.  
  37. Signing code for download
  38. =========================
  39.  
  40. Introduction
  41. ------------
  42. Document Overview
  43. -----------------
  44. This guide presents general information about how to use the tools provided
  45. with IE30 to generate and use cryptographic certificates with IE30.  It does 
  46. not attempt to provide an in-depth discussion of public key cryptography, 
  47. X.509 certificates, or certification policy.  See the recommended reading 
  48. list for suggested books and documents that will help you understand those 
  49. and other background issues.
  50.  
  51. Following this introduction, this guide is divided into the following 
  52. sections:
  53.  
  54. - Terminology
  55.  
  56.  Describes the terms used in this document that may be new to you.
  57.  
  58. - Procedural Overview
  59.  
  60.  This section gives a brief description of each step of the signing 
  61. procedure and an example of how it would be used by walking through a 
  62. sample session from start to finish.
  63.  
  64. - Required Files List
  65.  
  66. - Recommended Reading
  67.  
  68. Terminology
  69. -----------
  70. X.509 Certificate - A cryptographic certificate that associates an entity's 
  71. name with its public key.
  72.  
  73. PKCS 7 "SIGNED DATA" - A widely used convention for containing the data used 
  74. to sign an image or a document, typically including the certificate of the
  75. signer and a statement about the image made by the signer.
  76.  
  77. WIN_CERTIFICATE - A new Win32 defined data structure that contains either a 
  78. PKCS 7 signed data object or an X.509 Certificate.
  79.  
  80. Certification Authority (CA) - An entity that is making a statement
  81. (represented by an X.509 Certificate) about the authenticity of some
  82. other certificate.
  83.  
  84. SPC - Software Publishing Certificate.  A statement that the recipient is an 
  85. approved software vendor, represented as an X.509 certificate.
  86.  
  87. PE Image - Portable Executable Image, the standard Win32 executable 
  88. format.
  89.  
  90. Trust provider - A part of the operating system that verifies whether or not 
  91. a given image is trusted based on the certificates it contains.
  92.  
  93. Procedural Overview
  94. -------------------
  95. We will now walk through an example of how to sign an image.  Assume we are
  96. going to sign an image named image.exe.
  97.  
  98. This procedure is meant to illustrate the steps involved in signing an image 
  99. file.  Since creating a verifiable certificate assumes the existance of a 
  100. fairly complex CA infrastructure, it is not possible to provide all of the 
  101. pieces necessary for a fully trustworthy signature at this time.  In 
  102. particular, there does not exist a "top-level" certifying authority, which 
  103. would ultimately vouch for the integrity of the entire certificate chain.  
  104. Since such a top-level authority is a necessary part of the signing and 
  105. verification operations, the toolkit provided will create a pseudo top-level 
  106. entity when necessary.  This will be called the root authority or root key.
  107.  
  108. The present tools therefore allow any user of this development release to
  109. authorize themselves as a "Software Publisher" for test purposes and to
  110. sign their code, allowing for extensive testing of the tools and code
  111. used but not actually providing a secure infrastructure. In future releases,
  112. the tools will require software publishers to obtain certificates from
  113. companies whose function is to verify the identity of the publishers,
  114. providing end-users with a high level of assurance about the authenticity
  115. and origin of code that they recieve.
  116.  
  117. This sample root key will be used to generate an SPC (Software Publishing 
  118. Certificate), which is used to actually sign image files.
  119.  
  120.  
  121. 1) The first step is to run the MakeCert utility.  MakeCert will perform the 
  122. following tasks:
  123.  
  124. -  Create the end-user's public/private keypair suitable for digital 
  125. signatures, and associate the keypair with a friendly name.
  126.  
  127. -  Associate the new keypair with an X.500 Distinguished Name, and
  128.  
  129. -  Create an X.509 certificate signed by the root key that binds your name to 
  130. the public part of the newly created keypair.
  131.  
  132. A typical invocation of MakeCert is as follows:
  133.  
  134. c:\>makecert -u:MyKey -n:CN=MySoftwareCompany Cert.cer
  135.  
  136. Cert.crt now contains an X.509 certificate that binds your newly created key 
  137. with your name.  This certificate is itself signed by the example root key 
  138. described above.
  139.  
  140. A public key/private key pair will be generated and assigned the name
  141. specified in the "-u" switch, or if such a key already exists, it will
  142. be re-used.
  143.  
  144. Note that the name must be of the form "CN=[name-string]", as required by
  145. the ITU x.509 standard.
  146.  
  147. 2) The next step is to wrap the X.509 certificate created in step 1 into a 
  148. PKCS 7 signed-data object.  PKCS 7 objects are commonly used as "carriers" for 
  149. X.509 certificates, because it is possible to put several X.509 certificates 
  150. in a single PKCS 7 object.
  151.  
  152. In addition to the users's certificate, the root certificate will also be 
  153. inserted into the PKCS 7 object.  This will allow passing around the entire 
  154. certificate chain in a single container.
  155.  
  156. Do this with the Cert2SPC utility, as follows:
  157.  
  158. c:\>Cert2SPC Root.cer Cert.cer Cert.spc
  159.  
  160. Cert.spc now contains the Software Publishing Certificate in the correct 
  161. format.
  162.  
  163. 3) The next step is to use the certificate just created to sign an actual 
  164. image file.  Do this with the SignCode tool.  It takes as input the Cert.spc 
  165. file created in step 2, the name of the key pair created in step 1, and the 
  166. name of the image file to sign.
  167.  
  168. SignCode will perform the following tasks:
  169.  
  170. -  Create a cryptographic digest of the passed image file.
  171.  
  172. -  Sign the digest with the passed private key information.
  173.  
  174. -  Extract the X.509 certificates from the passed Cert.spc file.
  175.  
  176. -  Create a new PKCS 7 signed-data object containing the serial number of the 
  177. passed X.509 certificate and the signed digest information.
  178.  
  179. -  Embed the PKCS 7 object into the passed image file.
  180.  
  181. c:\>SignCode -prog image.exe -spc cert.spc -pvk MyKey
  182.  
  183. If SignCode is successful, image.exe will have a PKCS7 certificate embedded in 
  184. it.  Verify this by running PeSigMgr.exe on the image:
  185.  
  186. c:\>PeSigMgr -l image.exe
  187.  
  188.   Certificate   0 Revision 256 Type    PKCS7
  189.  
  190. 4) Now, check the validity of the image.  Do this with the ChkTrust utility.
  191.  
  192. c:\>ChkTrust image.exe
  193.  
  194. ChkTrust performs the following tasks:
  195.  
  196. -  Extract the PKCS 7 signed data object from the image.
  197.  
  198. -  Extract the X.509 certificates from the PKCS 7 object.
  199.  
  200. -  Compute a new cryptographic checksum of the image file and compare it with 
  201. the signed checksum in the PKCS 7 object.
  202.  
  203. -  If the image checks out, validate that the signer's X.509 certificate 
  204. points back to the root certificate, and that the root key used was correct.
  205.  
  206. If all this succeeds, the system has verified that the image has not been 
  207. tampered with, and that whoever published this piece of software was 
  208. authorized to do so by the root authority.
  209.  
  210. List of Required Files
  211. ----------------------
  212. WINTRUST.DLL   (In System/System32 directory)
  213. DIGSIG.DLL     (In System/System32 directory)
  214. MAKECERT.EXE
  215. CERT2SPC.EXE
  216. SIGNCODE.EXE
  217. PESIGMGR.EXE
  218. CHKTRUST.EXE
  219. ROOT.CER
  220. ROOT.PVK
  221.