Files
dotnet-bot adf899c629 Adding System.Data..., System.ServiceModel..., and System.Web...
Adding reference source for
System.Data
System.Data.DataSetExtensions
System.Data.Entity
System.Data.Entity.Design
System.Data.Linq
System.Data.SqlXml
System.ServiceModel
System.ServiceModel.Activation
System.ServiceModel.Activities
System.ServiceModel.Channels
System.ServiceModel.Discovery
System.ServiceModel.Internals
System.ServiceModel.Routing
System.ServiceModel.WasHosting
System.ServiceModel.Web
System.Web
System.Web.ApplicationServices
System.Web.DynamicData
System.Web.Entity
System.Web.Entity.Design
System.Web.Extensions
System.Web.Mobile
System.Web.Routing
System.Web.Services
System.Xml
System.Xml.Linq
2016-05-03 00:07:37 +02:00

312 lines
12 KiB
C#

//------------------------------------------------------------------------------
// <copyright file="HttpClientCertificate.cs" company="Microsoft">
// Copyright (c) Microsoft Corporation. All rights reserved.
// </copyright>
//------------------------------------------------------------------------------
/*
* Client Certificate
*
* Copyright (c) 2000 Microsoft Corporation
*/
namespace System.Web {
using System.Collections;
using System.Collections.Specialized;
using System.Globalization;
using System.Security.Permissions;
using System.Web.Util;
/// <devdoc>
/// <para>The HttpClientCertificate collection retrieves the certification fields
/// (specified in the X.509 standard) from a request issued by the Web browser.</para>
/// <para>If a Web browser uses the SSL3.0/PCT1 protocol (in other words, it uses a URL
/// starting with https:// instead of http://) to connect to a server and the server
/// requests certification, the browser sends the certification fields.</para>
/// </devdoc>
public class HttpClientCertificate : NameValueCollection {
/////////////////////////////////////////////////////////////////////////////
// Properties
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public String Cookie { get { return _Cookie;}}
/// <devdoc>
/// A string containing the binary stream of the entire certificate content in ASN.1 format.
/// </devdoc>
public byte [] Certificate { get { return _Certificate;}}
/// <devdoc>
/// <para>A set of flags that provide additional client certificate information. </para>
/// </devdoc>
public int Flags { get { return _Flags;}}
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public int KeySize { get { return _KeySize;}}
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public int SecretKeySize { get { return _SecretKeySize;}}
/// <devdoc>
/// <para>A string that contains a list of subfield values containing information about
/// the issuer of the certificate.</para>
/// </devdoc>
public String Issuer { get { return _Issuer;}}
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public String ServerIssuer { get { return _ServerIssuer;}}
/// <devdoc>
/// <para>A string that contains a list of subfield values. The subfield values contain
/// information about the subject of the certificate. If this value is specified
/// without a <paramref name="SubField"/>, the ClientCertificate collection returns a
/// comma-separated list of subfields. For example, C=US, O=Msft, and so on.</para>
/// </devdoc>
public String Subject { get { return _Subject;}}
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public String ServerSubject { get { return _ServerSubject;}}
/// <devdoc>
/// <para>A string that contains the certification serial number as an ASCII
/// representation of hexadecimal bytes separated by hyphens (-). For example,
/// 04-67-F3-02.</para>
/// </devdoc>
public String SerialNumber { get { return _SerialNumber;}}
/// <devdoc>
/// <para>A date specifying when the certificate becomes valid. This date varies with
/// international settings. </para>
/// </devdoc>
public DateTime ValidFrom { get { return _ValidFrom;}}
/// <devdoc>
/// <para>A date specifying when the certificate expires. The year value is displayed
/// as a four-digit number.</para>
/// </devdoc>
public DateTime ValidUntil { get { return _ValidUntil;}}
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public int CertEncoding { get { return _CertEncoding;}}
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public byte [] PublicKey { get { return _PublicKey;}}
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public byte [] BinaryIssuer { get { return _BinaryIssuer;}}
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public bool IsPresent { get { return((_Flags & 0x1) == 1);}}
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public bool IsValid { get { return((_Flags & 0x2) == 0);}}
/////////////////////////////////////////////////////////////////////////////
// Ctor
internal HttpClientCertificate(HttpContext context) {
String flags = context.Request.ServerVariables["CERT_FLAGS"];
if (!String.IsNullOrEmpty(flags))
_Flags = Int32.Parse(flags, CultureInfo.InvariantCulture);
else
_Flags = 0;
if (IsPresent == false)
return;
_Cookie = context.Request.ServerVariables["CERT_COOKIE"];
_Issuer = context.Request.ServerVariables["CERT_ISSUER"];
_ServerIssuer = context.Request.ServerVariables["CERT_SERVER_ISSUER"];
_Subject = context.Request.ServerVariables["CERT_SUBJECT"];
_ServerSubject = context.Request.ServerVariables["CERT_SERVER_SUBJECT"];
_SerialNumber = context.Request.ServerVariables["CERT_SERIALNUMBER"];
_Certificate = context.WorkerRequest.GetClientCertificate();
_ValidFrom = context.WorkerRequest.GetClientCertificateValidFrom();
_ValidUntil = context.WorkerRequest.GetClientCertificateValidUntil();
_BinaryIssuer = context.WorkerRequest.GetClientCertificateBinaryIssuer();
_PublicKey = context.WorkerRequest.GetClientCertificatePublicKey();
_CertEncoding = context.WorkerRequest.GetClientCertificateEncoding();
String keySize = context.Request.ServerVariables["CERT_KEYSIZE"];
String skeySize = context.Request.ServerVariables["CERT_SECRETKEYSIZE"];
if (!String.IsNullOrEmpty(keySize))
_KeySize = Int32.Parse(keySize, CultureInfo.InvariantCulture);
if (!String.IsNullOrEmpty(skeySize))
_SecretKeySize = Int32.Parse(skeySize, CultureInfo.InvariantCulture);
base.Add("ISSUER", null);
base.Add("SUBJECTEMAIL", null);
base.Add("BINARYISSUER", null);
base.Add("FLAGS", null);
base.Add("ISSUERO", null);
base.Add("PUBLICKEY", null);
base.Add("ISSUEROU", null);
base.Add("ENCODING", null);
base.Add("ISSUERCN", null);
base.Add("SERIALNUMBER", null);
base.Add("SUBJECT", null);
base.Add("SUBJECTCN", null);
base.Add("CERTIFICATE", null);
base.Add("SUBJECTO", null);
base.Add("SUBJECTOU", null);
base.Add("VALIDUNTIL", null);
base.Add("VALIDFROM", null);
}
/// <devdoc>
/// <para>Allows access to individual items in the collection by name.</para>
/// </devdoc>
public override String Get(String field)
{
if (field == null)
return String.Empty;
field = field.ToLower(CultureInfo.InvariantCulture);
switch (field) {
case "cookie":
return Cookie;
case "flags":
return Flags.ToString("G", CultureInfo.InvariantCulture);
case "keysize":
return KeySize.ToString("G", CultureInfo.InvariantCulture);
case "secretkeysize":
return SecretKeySize.ToString(CultureInfo.InvariantCulture);
case "issuer":
return Issuer;
case "serverissuer":
return ServerIssuer;
case "subject":
return Subject;
case "serversubject":
return ServerSubject;
case "serialnumber":
return SerialNumber;
case "certificate":
return System.Text.Encoding.Default.GetString(Certificate);
case "binaryissuer":
return System.Text.Encoding.Default.GetString(BinaryIssuer);
case "publickey":
return System.Text.Encoding.Default.GetString(PublicKey);
case "encoding":
return CertEncoding.ToString("G", CultureInfo.InvariantCulture);
case "validfrom":
return HttpUtility.FormatHttpDateTime(ValidFrom);
case "validuntil":
return HttpUtility.FormatHttpDateTime(ValidUntil);
}
if (StringUtil.StringStartsWith(field, "issuer"))
return ExtractString(Issuer, field.Substring(6));
if (StringUtil.StringStartsWith(field, "subject")) {
if (field.Equals("subjectemail"))
return ExtractString(Subject, "e");
else
return ExtractString(Subject, field.Substring(7));
}
if (StringUtil.StringStartsWith(field, "serversubject"))
return ExtractString(ServerSubject, field.Substring(13));
if (StringUtil.StringStartsWith(field, "serverissuer"))
return ExtractString(ServerIssuer, field.Substring(12));
return String.Empty;
}
/////////////////////////////////////////////////////////////////////////////
// Private data
private String _Cookie = String.Empty;
private byte [] _Certificate = new byte[0];
private int _Flags;
private int _KeySize;
private int _SecretKeySize;
private String _Issuer = String.Empty;
private String _ServerIssuer = String.Empty;
private String _Subject = String.Empty;
private String _ServerSubject = String.Empty;
private String _SerialNumber = String.Empty;
private DateTime _ValidFrom = DateTime.Now;
private DateTime _ValidUntil = DateTime.Now;
private int _CertEncoding;
private byte [] _PublicKey = new byte[0];
private byte [] _BinaryIssuer = new byte[0];
private String ExtractString(String strAll, String strSubject) {
if (strAll == null || strSubject == null)
return String.Empty;
String strReturn = String.Empty;
int iStart = 0;
String strAllL = strAll.ToLower(CultureInfo.InvariantCulture);
while (iStart < strAllL.Length) {
iStart = strAllL.IndexOf(strSubject + "=", iStart, StringComparison.Ordinal);
if (iStart < 0)
return strReturn;
if (strReturn.Length > 0)
strReturn += ";";
iStart += strSubject.Length + 1;
int iEnd = 0;
if (strAll[iStart]=='"') {
iStart++;
iEnd = strAll.IndexOf('"' , iStart);
}
else
iEnd = strAll.IndexOf(',' , iStart);
if (iEnd < 0)
iEnd = strAll.Length;
strReturn += strAll.Substring(iStart, iEnd - iStart);
iStart = iEnd + 1;
}
return strReturn;
}
}
}