223 lines
7.9 KiB
C#
223 lines
7.9 KiB
C#
using System;
|
|
using System.IO;
|
|
|
|
namespace Unosquare.Swan.Networking.Ldap {
|
|
/// <summary>
|
|
/// This class provides LBER encoding routines for ASN.1 Types. LBER is a
|
|
/// subset of BER as described in the following taken from 5.1 of RFC 2251:
|
|
/// 5.1. Mapping Onto BER-based Transport Services
|
|
/// The protocol elements of Ldap are encoded for exchange using the
|
|
/// Basic Encoding Rules (BER) [11] of ASN.1 [3]. However, due to the
|
|
/// high overhead involved in using certain elements of the BER, the
|
|
/// following additional restrictions are placed on BER-encodings of Ldap
|
|
/// protocol elements:
|
|
/// <li>(1) Only the definite form of length encoding will be used.</li>
|
|
/// <li>(2) OCTET STRING values will be encoded in the primitive form only.</li><li>
|
|
/// (3) If the value of a BOOLEAN type is true, the encoding MUST have
|
|
/// its contents octets set to hex "FF".
|
|
/// </li><li>
|
|
/// (4) If a value of a type is its default value, it MUST be absent.
|
|
/// Only some BOOLEAN and INTEGER types have default values in this
|
|
/// protocol definition.
|
|
/// These restrictions do not apply to ASN.1 types encapsulated inside of
|
|
/// OCTET STRING values, such as attribute values, unless otherwise
|
|
/// noted.
|
|
/// </li>
|
|
/// [3] ITU-T Rec. X.680, "Abstract Syntax Notation One (ASN.1) -
|
|
/// Specification of Basic Notation", 1994.
|
|
/// [11] ITU-T Rec. X.690, "Specification of ASN.1 encoding rules: Basic,
|
|
/// Canonical, and Distinguished Encoding Rules", 1994.
|
|
/// </summary>
|
|
internal static class LberEncoder {
|
|
/// <summary>
|
|
/// BER Encode an Asn1Boolean directly into the specified output stream.
|
|
/// </summary>
|
|
/// <param name="b">The Asn1Boolean object to encode.</param>
|
|
/// <param name="stream">The stream.</param>
|
|
public static void Encode(Asn1Boolean b, Stream stream) {
|
|
Encode(b.GetIdentifier(), stream);
|
|
stream.WriteByte(0x01);
|
|
stream.WriteByte((Byte)(b.BooleanValue() ? 0xff : 0x00));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Encode an Asn1Numeric directly into the specified outputstream.
|
|
/// Use a two's complement representation in the fewest number of octets
|
|
/// possible.
|
|
/// Can be used to encode INTEGER and ENUMERATED values.
|
|
/// </summary>
|
|
/// <param name="n">The Asn1Numeric object to encode.</param>
|
|
/// <param name="stream">The stream.</param>
|
|
public static void Encode(Asn1Numeric n, Stream stream) {
|
|
SByte[] octets = new SByte[8];
|
|
SByte len;
|
|
Int64 longValue = n.LongValue();
|
|
Int64 endValue = longValue < 0 ? -1 : 0;
|
|
Int64 endSign = endValue & 0x80;
|
|
|
|
for(len = 0; len == 0 || longValue != endValue || (octets[len - 1] & 0x80) != endSign; len++) {
|
|
octets[len] = (SByte)(longValue & 0xFF);
|
|
longValue >>= 8;
|
|
}
|
|
|
|
Encode(n.GetIdentifier(), stream);
|
|
stream.WriteByte((Byte)len);
|
|
|
|
for(Int32 i = len - 1; i >= 0; i--) {
|
|
stream.WriteByte((Byte)octets[i]);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Encode an Asn1OctetString directly into the specified outputstream.
|
|
/// </summary>
|
|
/// <param name="os">The Asn1OctetString object to encode.</param>
|
|
/// <param name="stream">The stream.</param>
|
|
public static void Encode(Asn1OctetString os, Stream stream) {
|
|
Encode(os.GetIdentifier(), stream);
|
|
EncodeLength(os.ByteValue().Length, stream);
|
|
SByte[] tempSbyteArray = os.ByteValue();
|
|
stream.Write(tempSbyteArray.ToByteArray(), 0, tempSbyteArray.Length);
|
|
}
|
|
|
|
public static void Encode(Asn1Object obj, Stream stream) {
|
|
switch(obj) {
|
|
case Asn1Boolean b:
|
|
Encode(b, stream);
|
|
break;
|
|
case Asn1Numeric n:
|
|
Encode(n, stream);
|
|
break;
|
|
case Asn1Null n:
|
|
Encode(n.GetIdentifier(), stream);
|
|
stream.WriteByte(0x00); // Length (with no Content)
|
|
break;
|
|
case Asn1OctetString n:
|
|
Encode(n, stream);
|
|
break;
|
|
case Asn1Structured n:
|
|
Encode(n, stream);
|
|
break;
|
|
case Asn1Tagged n:
|
|
Encode(n, stream);
|
|
break;
|
|
case Asn1Choice n:
|
|
Encode(n.ChoiceValue, stream);
|
|
break;
|
|
default:
|
|
throw new InvalidDataException();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Encode an Asn1Structured into the specified outputstream. This method
|
|
/// can be used to encode SET, SET_OF, SEQUENCE, SEQUENCE_OF.
|
|
/// </summary>
|
|
/// <param name="c">The Asn1Structured object to encode.</param>
|
|
/// <param name="stream">The stream.</param>
|
|
public static void Encode(Asn1Structured c, Stream stream) {
|
|
Encode(c.GetIdentifier(), stream);
|
|
|
|
Asn1Object[] arrayValue = c.ToArray();
|
|
|
|
using(MemoryStream output = new MemoryStream()) {
|
|
foreach(Asn1Object obj in arrayValue) {
|
|
Encode(obj, output);
|
|
}
|
|
|
|
EncodeLength((Int32)output.Length, stream);
|
|
|
|
Byte[] tempSbyteArray = output.ToArray();
|
|
stream.Write(tempSbyteArray, 0, tempSbyteArray.Length);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Encode an Asn1Tagged directly into the specified outputstream.
|
|
/// </summary>
|
|
/// <param name="t">The Asn1Tagged object to encode.</param>
|
|
/// <param name="stream">The stream.</param>
|
|
public static void Encode(Asn1Tagged t, Stream stream) {
|
|
if(!t.Explicit) {
|
|
Encode(t.TaggedValue, stream);
|
|
return;
|
|
}
|
|
|
|
Encode(t.GetIdentifier(), stream);
|
|
|
|
// determine the encoded length of the base type.
|
|
using(MemoryStream encodedContent = new MemoryStream()) {
|
|
Encode(t.TaggedValue, encodedContent);
|
|
|
|
EncodeLength((Int32)encodedContent.Length, stream);
|
|
SByte[] tempSbyteArray = encodedContent.ToArray().ToSByteArray();
|
|
stream.Write(tempSbyteArray.ToByteArray(), 0, tempSbyteArray.Length);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Encode an Asn1Identifier directly into the specified outputstream.
|
|
/// </summary>
|
|
/// <param name="id">The Asn1Identifier object to encode.</param>
|
|
/// <param name="stream">The stream.</param>
|
|
public static void Encode(Asn1Identifier id, Stream stream) {
|
|
Int32 c = (Int32)id.Asn1Class;
|
|
Int32 t = id.Tag;
|
|
SByte ccf = (SByte)((c << 6) | (id.Constructed ? 0x20 : 0));
|
|
|
|
if(t < 30) {
|
|
#pragma warning disable CS0675 // Bitweiser OR-Operator, der bei einem signaturerweiterten Operanden verwendet wurde.
|
|
stream.WriteByte((Byte)(ccf | t));
|
|
#pragma warning restore CS0675 // Bitweiser OR-Operator, der bei einem signaturerweiterten Operanden verwendet wurde.
|
|
} else {
|
|
stream.WriteByte((Byte)(ccf | 0x1F));
|
|
EncodeTagInteger(t, stream);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Encodes the length.
|
|
/// </summary>
|
|
/// <param name="length">The length.</param>
|
|
/// <param name="stream">The stream.</param>
|
|
private static void EncodeLength(Int32 length, Stream stream) {
|
|
if(length < 0x80) {
|
|
stream.WriteByte((Byte)length);
|
|
} else {
|
|
SByte[] octets = new SByte[4]; // 4 bytes sufficient for 32 bit int.
|
|
SByte n;
|
|
for(n = 0; length != 0; n++) {
|
|
octets[n] = (SByte)(length & 0xFF);
|
|
length >>= 8;
|
|
}
|
|
|
|
stream.WriteByte((Byte)(0x80 | n));
|
|
|
|
for(Int32 i = n - 1; i >= 0; i--) {
|
|
stream.WriteByte((Byte)octets[i]);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Encodes the provided tag into the stream.
|
|
/// </summary>
|
|
/// <param name="val">The value.</param>
|
|
/// <param name="stream">The stream.</param>
|
|
private static void EncodeTagInteger(Int32 val, Stream stream) {
|
|
SByte[] octets = new SByte[5];
|
|
Int32 n;
|
|
|
|
for(n = 0; val != 0; n++) {
|
|
octets[n] = (SByte)(val & 0x7F);
|
|
val >>= 7;
|
|
}
|
|
|
|
for(Int32 i = n - 1; i > 0; i--) {
|
|
stream.WriteByte((Byte)(octets[i] | 0x80));
|
|
}
|
|
|
|
stream.WriteByte((Byte)octets[0]);
|
|
}
|
|
}
|
|
} |