static bool Method( ReadOnlySpan <byte> source, Span <byte> destination, AsnEncodingRules ruleSet, out int consumed, out int written) { bool ret = AsnDecoder.TryReadBitString( source, destination, ruleSet, out int unusedBitCount, out consumed, out written); if (ret) { Assert.Equal(2, unusedBitCount); } return(ret); }
public static ReadOnlyMemory <byte> DecodeOctetStringAsMemory(ReadOnlyMemory <byte> encodedOctetString) { try { ReadOnlySpan <byte> input = encodedOctetString.Span; if (AsnDecoder.TryReadPrimitiveOctetString( input, AsnEncodingRules.BER, out ReadOnlySpan <byte> primitive, out int consumed)) { if (consumed != input.Length) { throw new CryptographicException(SR.Cryptography_Der_Invalid_Encoding); } if (input.Overlaps(primitive, out int offset)) { return(encodedOctetString.Slice(offset, primitive.Length)); } Debug.Fail("input.Overlaps(primitive) failed after TryReadPrimitiveOctetString succeeded"); } byte[] ret = AsnDecoder.ReadOctetString(input, AsnEncodingRules.BER, out consumed); if (consumed != input.Length) { throw new CryptographicException(SR.Cryptography_Der_Invalid_Encoding); } return(ret); } catch (AsnContentException e) { throw new CryptographicException(SR.Cryptography_Der_Invalid_Encoding, e); } }
public static DateTime DecodeUtcTime(byte[] encodedUtcTime) { // Read using BER because the CMS specification says the encoding is BER. try { DateTimeOffset value = AsnDecoder.ReadUtcTime( encodedUtcTime, AsnEncodingRules.BER, out int consumed); if (consumed != encodedUtcTime.Length) { throw new CryptographicException(SR.Cryptography_Der_Invalid_Encoding); } return(value.UtcDateTime); } catch (AsnContentException e) { throw new CryptographicException(SR.Cryptography_Der_Invalid_Encoding, e); } }
public static void PeekEncodedValue_InvalidLength() { byte[] badLength = "04040203".HexToByteArray(); AsnReader reader = new AsnReader(badLength, AsnEncodingRules.BER); Assert.Throws <AsnContentException>(() => reader.PeekEncodedValue()); Assert.Throws <AsnContentException>(() => reader.ReadEncodedValue()); Assert.False( AsnDecoder.TryReadEncodedValue( badLength, AsnEncodingRules.BER, out Asn1Tag tag, out int contentOffset, out int contentLength, out int bytesConsumed)); Assert.Equal(0, contentOffset); Assert.Equal(0, contentLength); Assert.Equal(0, bytesConsumed); Assert.Equal(default(Asn1Tag), tag); }
protected static ECParameters ReadOpenPgpECParameters(ReadOnlySpan <byte> source, out int bytesRead) { ECParameters ecParameters = new ECParameters(); int oidLength = source[0]; // TODO: Validate oidLength var oidBytes = new byte[oidLength + 2]; oidBytes[0] = 6; oidBytes[1] = (byte)oidLength; source.Slice(1, oidLength).CopyTo(oidBytes.AsSpan(2)); var oid = new Oid(AsnDecoder.ReadObjectIdentifier(oidBytes, AsnEncodingRules.DER, out _)); ecParameters.Curve = ECCurve.CreateFromOid(oid); var pointBytes = MPInteger.ReadInteger(source.Slice(oidLength + 1), out bytesRead); bytesRead += oidLength + 1; ecParameters.Q = DecodePoint(pointBytes); return(ecParameters); }
internal static byte[] DecodeX509SubjectKeyIdentifierExtension(byte[] encoded) { ReadOnlySpan <byte> contents; try { bool gotContents = AsnDecoder.TryReadPrimitiveOctetString( encoded, AsnEncodingRules.BER, out contents, out int consumed); if (!gotContents || consumed != encoded.Length) { throw new CryptographicException(SR.Cryptography_Der_Invalid_Encoding); } } catch (AsnContentException e) { throw new CryptographicException(SR.Cryptography_Der_Invalid_Encoding, e); } return(contents.ToArray()); }
public static void ParseCorruptTag(string description, string inputHex) { _ = description; byte[] inputBytes = inputHex.HexToByteArray(); Assert.False(Asn1Tag.TryDecode(inputBytes, out Asn1Tag tag, out var bytesRead)); Assert.Equal(default(Asn1Tag), tag); Assert.Equal(0, bytesRead); Assert.False( AsnDecoder.TryReadEncodedValue( inputBytes, AsnEncodingRules.BER, out tag, out int contentOffset, out int contentLength, out int bytesConsumed)); Assert.Equal(0, contentOffset); Assert.Equal(0, contentLength); Assert.Equal(0, bytesConsumed); Assert.Equal(default(Asn1Tag), tag); }
internal static unsafe Pkcs8Response ImportEncryptedPkcs8PrivateKey( ReadOnlySpan <char> password, ReadOnlySpan <byte> source, out int bytesRead) { try { AsnDecoder.ReadEncodedValue( source, AsnEncodingRules.BER, out _, out _, out int len); source = source.Slice(0, len); fixed(byte *ptr = &MemoryMarshal.GetReference(source)) { using (MemoryManager <byte> manager = new PointerMemoryManager <byte>(ptr, source.Length)) { try { bytesRead = len; return(ImportPkcs8(source, password)); } catch (CryptographicException) { } ArraySegment <byte> decrypted = KeyFormatHelper.DecryptPkcs8( password, manager.Memory.Slice(0, len), out int innerRead); Span <byte> decryptedSpan = decrypted; try { if (innerRead != len) { throw new CryptographicException(SR.Cryptography_Der_Invalid_Encoding); } bytesRead = len; return(ImportPkcs8(decryptedSpan)); } catch (CryptographicException e) { AsnWriter?pkcs8ZeroPublicKey = RewritePkcs8ECPrivateKeyWithZeroPublicKey(decryptedSpan); if (pkcs8ZeroPublicKey == null) { throw new CryptographicException(SR.Cryptography_Pkcs8_EncryptedReadFailed, e); } try { bytesRead = len; return(ImportPkcs8(pkcs8ZeroPublicKey)); } catch (CryptographicException) { throw new CryptographicException(SR.Cryptography_Pkcs8_EncryptedReadFailed, e); } } finally { CryptographicOperations.ZeroMemory(decryptedSpan); CryptoPool.Return(decrypted.Array !, clearSize: 0); } } } } catch (AsnContentException e) { throw new CryptographicException(SR.Cryptography_Der_Invalid_Encoding, e); } }
/// <summary> /// Reads the next value as a NULL with a specified tag. /// </summary> /// <param name="expectedTag"> /// The tag to check for before reading, or <see langword="null"/> for the default tag (Universal 5). /// </param> /// <exception cref="AsnContentException"> /// the next value does not have the correct tag. /// /// -or- /// /// the length encoding is not valid under the current encoding rules. /// /// -or- /// /// the contents are not valid under the current encoding rules. /// </exception> /// <exception cref="ArgumentException"> /// <paramref name="expectedTag"/>.<see cref="Asn1Tag.TagClass"/> is /// <see cref="TagClass.Universal"/>, but /// <paramref name="expectedTag"/>.<see cref="Asn1Tag.TagValue"/> is not correct for /// the method. /// </exception> public void ReadNull(Asn1Tag?expectedTag = null) { AsnDecoder.ReadNull(_data.Span, RuleSet, out int consumed, expectedTag); _data = _data.Slice(consumed); }