/// <summary>
/// Wraps the 'Void Reset()' on the 'System.Collections.IEnumerator' type.
/// </summary>
public virtual void Reset()
{
var type = WrapperUtilities.GetTypeFromCache("System.Collections.IEnumerator", "mscorlib", TypeCache);
var methodInfo = WrapperUtilities.GetMethodInfo(type, MethodInfoCache, "Void Reset()");
WrapperUtilities.InvokeMethodWithoutResult(this, methodInfo, new object[] { });
}
/// <summary>
/// Wraps the 'Boolean MoveNext()' on the 'System.Collections.IEnumerator' type.
/// </summary>
/// <returns>The value returned by the underlying method.</returns>
public virtual bool MoveNext()
{
var type = WrapperUtilities.GetTypeFromCache("System.Collections.IEnumerator", "mscorlib", TypeCache);
var methodInfo = WrapperUtilities.GetMethodInfo(type, MethodInfoCache, "Boolean MoveNext()");
return(WrapperUtilities.InvokeMethodAndCast <bool>(this, methodInfo, new object[] { }));
}
/// <summary>
/// Gets a value of the 'Item' property on 'System.Collections.ObjectModel.ReadOnlyCollection`1'
/// </summary>
/// <param name="index">The value of the 'index' parameter.</param>
public virtual T this[int index]
{
get
{
return(WrapperUtilities.InvokeMethodAndWrap <T>(this, WrapperUtilities.GetMethodInfo(WrappedObjectType, MethodInfoCache, "T get_Item(Int32)"), new object[] { index }));
}
}
public override CmsTypedStream GetContentStream(ICipherParameters key)
{
CmsTypedStream contentFromSessionKey;
try
{
AlgorithmIdentifier instance = AlgorithmIdentifier.GetInstance(this.info.KeyEncryptionAlgorithm);
Asn1Sequence asn1Sequence = (Asn1Sequence)instance.Parameters;
byte[] octets = this.info.EncryptedKey.GetOctets();
string id = DerObjectIdentifier.GetInstance(asn1Sequence[0]).Id;
string rfc3211WrapperName = CmsEnvelopedHelper.Instance.GetRfc3211WrapperName(id);
IWrapper wrapper = WrapperUtilities.GetWrapper(rfc3211WrapperName);
byte[] octets2 = Asn1OctetString.GetInstance(asn1Sequence[1]).GetOctets();
ICipherParameters parameters = ((CmsPbeKey)key).GetEncoded(id);
parameters = new ParametersWithIV(parameters, octets2);
wrapper.Init(false, parameters);
KeyParameter sKey = ParameterUtilities.CreateKeyParameter(base.GetContentAlgorithmName(), wrapper.Unwrap(octets, 0, octets.Length));
contentFromSessionKey = base.GetContentFromSessionKey(sKey);
}
catch (SecurityUtilityException e)
{
throw new CmsException("couldn't create cipher.", e);
}
catch (InvalidKeyException e2)
{
throw new CmsException("key invalid in message.", e2);
}
return(contentFromSessionKey);
}
/**
* decrypt the content and return an input stream.
*/
public override CmsTypedStream GetContentStream(
ICipherParameters key)
{
try
{
byte[] encryptedKey = info.EncryptedKey.GetOctets();
IWrapper keyWrapper = WrapperUtilities.GetWrapper(keyEncAlg.ObjectID.Id);
keyWrapper.Init(false, key);
AlgorithmIdentifier aid = GetActiveAlgID();
KeyParameter sKey = ParameterUtilities.CreateKeyParameter(
aid.ObjectID, keyWrapper.Unwrap(encryptedKey, 0, encryptedKey.Length));
return(GetContentFromSessionKey(sKey));
}
catch (SecurityUtilityException e)
{
throw new CmsException("couldn't create cipher.", e);
}
catch (InvalidKeyException e)
{
throw new CmsException("key invalid in message.", e);
}
}
/// <summary>
/// Wraps the 'System.String ToString()' on the 'System.IO.Stream' type.
/// </summary>
/// <returns>The value returned by the underlying method.</returns>
public override string ToString()
{
var type = WrapperUtilities.GetTypeFromCache("System.Object", "mscorlib", TypeCache);
var methodInfo = WrapperUtilities.GetMethodInfo(type, MethodInfoCache, "System.String ToString()");
return(WrapperUtilities.InvokeMethodAndCast <string>(this, methodInfo, new object[] { }));
}
/**
* decrypt the content and return an input stream.
*/
public override CmsTypedStream GetContentStream(
ICipherParameters key)
{
try
{
AlgorithmIdentifier kekAlg = AlgorithmIdentifier.GetInstance(info.KeyEncryptionAlgorithm);
Asn1Sequence kekAlgParams = (Asn1Sequence)kekAlg.Parameters;
byte[] encryptedKey = info.EncryptedKey.GetOctets();
string kekAlgName = DerObjectIdentifier.GetInstance(kekAlgParams[0]).Id;
string cName = CmsEnvelopedHelper.Instance.GetRfc3211WrapperName(kekAlgName);
IWrapper keyWrapper = WrapperUtilities.GetWrapper(cName);
byte[] iv = Asn1OctetString.GetInstance(kekAlgParams[1]).GetOctets();
ICipherParameters parameters = ((CmsPbeKey)key).GetEncoded(kekAlgName);
parameters = new ParametersWithIV(parameters, iv);
keyWrapper.Init(false, parameters);
KeyParameter sKey = ParameterUtilities.CreateKeyParameter(
GetContentAlgorithmName(), keyWrapper.Unwrap(encryptedKey, 0, encryptedKey.Length));
return(GetContentFromSessionKey(sKey));
}
catch (SecurityUtilityException e)
{
throw new CmsException("couldn't create cipher.", e);
}
catch (InvalidKeyException e)
{
throw new CmsException("key invalid in message.", e);
}
}
/// <summary>
/// Wraps the 'Void Write(Byte[], Int32, Int32)' on the 'System.IO.Stream' type.
/// </summary>
/// <param name="buffer">The value of the 'buffer' parameter.</param>
/// <param name="offset">The value of the 'offset' parameter.</param>
/// <param name="count">The value of the 'count' parameter.</param>
public override void Write(byte[] buffer, int offset, int count)
{
var type = WrapperUtilities.GetTypeFromCache("System.IO.Stream", "mscorlib", TypeCache);
var methodInfo = WrapperUtilities.GetMethodInfo(type, MethodInfoCache, "Void Write(Byte[], Int32, Int32)");
WrapperUtilities.InvokeMethodWithoutResult(this, methodInfo, new object[] { buffer, offset, count });
}
/// <summary>
/// Wraps the 'System.Collections.IEnumerator GetEnumerator()' on the 'System.Linq.IQueryable' type.
/// </summary>
/// <returns>The value returned by the underlying method.</returns>
public virtual System.Collections.IEnumerator GetEnumerator()
{
var type = WrapperUtilities.GetTypeFromCache("System.Collections.IEnumerable", "mscorlib", TypeCache);
var methodInfo = WrapperUtilities.GetMethodInfo(type, MethodInfoCache, "System.Collections.IEnumerator GetEnumerator()");
return((System.Collections.IEnumerator)ProxyFactory.CreateProxyIfPossible(this.Scope, WrapperUtilities.InvokeMethodAndCast <System.Collections.IEnumerator>(this, methodInfo, new object[] { }), typeof(System.Collections.IEnumerator)));
}
/// <summary>
/// Wraps the 'System.Linq.IQueryable`1[TElement] CreateQuery[TElement](System.Linq.Expressions.Expression)' on the 'System.Linq.IQueryProvider' type.
/// </summary>
/// <typeparam name="TElement">The wrapper type for the 'TElement' generic parameter.</typeparam>
/// <param name="expression">The value of the 'expression' parameter.</param>
/// <returns>The value returned by the underlying method.</returns>
public virtual System.Linq.IQueryable <TElement> CreateQuery <TElement>(System.Linq.Expressions.Expression expression)
{
var type = WrapperUtilities.GetTypeFromCache("System.Linq.IQueryProvider", "System.Core", TypeCache);
var methodInfo = WrapperUtilities.GetMethodInfo(type, MethodInfoCache, "System.Linq.IQueryable`1[TElement] CreateQuery[TElement](System.Linq.Expressions.Expression)");
return((System.Linq.IQueryable <TElement>)ProxyFactory.CreateProxyIfPossible(this.Scope, WrapperUtilities.InvokeMethodAndCast <System.Linq.IQueryable <TElement> >(this, methodInfo, new object[] { expression }, new Type[] { typeof(TElement) }), typeof(System.Linq.IQueryable <TElement>)));
}
/// <summary>
/// Wraps the 'System.IAsyncResult BeginWrite(Byte[], Int32, Int32, System.AsyncCallback, System.Object)' on the 'System.IO.Stream' type.
/// </summary>
/// <param name="buffer">The value of the 'buffer' parameter.</param>
/// <param name="offset">The value of the 'offset' parameter.</param>
/// <param name="count">The value of the 'count' parameter.</param>
/// <param name="callback">The value of the 'callback' parameter.</param>
/// <param name="state">The value of the 'state' parameter.</param>
/// <returns>The value returned by the underlying method.</returns>
public override System.IAsyncResult BeginWrite(byte[] buffer, int offset, int count, System.AsyncCallback callback, object state)
{
var type = WrapperUtilities.GetTypeFromCache("System.IO.Stream", "mscorlib", TypeCache);
var methodInfo = WrapperUtilities.GetMethodInfo(type, MethodInfoCache, "System.IAsyncResult BeginWrite(Byte[], Int32, Int32, System.AsyncCallback, System.Object)");
return(WrapperUtilities.InvokeMethodAndCast <System.IAsyncResult>(this, methodInfo, new object[] { buffer, offset, count, callback, state }));
}
internal KeyParameter UnwrapKey(ICipherParameters key)
{
byte[] encryptedKey = info.EncryptedKey.GetOctets();
string keyExchangeAlgorithm = GetExchangeEncryptionAlgorithmName(keyEncAlg.Algorithm);
try
{
IWrapper keyWrapper = WrapperUtilities.GetWrapper(keyExchangeAlgorithm);
keyWrapper.Init(false, key);
// FIXME Support for MAC algorithm parameters similar to cipher parameters
return(ParameterUtilities.CreateKeyParameter(
GetContentAlgorithmName(), keyWrapper.Unwrap(encryptedKey, 0, encryptedKey.Length)));
}
catch (SecurityUtilityException e)
{
throw new CmsException("couldn't create cipher.", e);
}
catch (InvalidKeyException e)
{
throw new CmsException("key invalid in message.", e);
}
// catch (IllegalBlockSizeException e)
catch (DataLengthException e)
{
throw new CmsException("illegal blocksize in message.", e);
}
// catch (BadPaddingException e)
catch (InvalidCipherTextException e)
{
throw new CmsException("bad padding in message.", e);
}
}
/// <summary>
/// Wraps the 'System.Object Execute(System.Linq.Expressions.Expression)' on the 'System.Linq.IQueryProvider' type.
/// </summary>
/// <param name="expression">The value of the 'expression' parameter.</param>
/// <returns>The value returned by the underlying method.</returns>
public virtual object Execute(System.Linq.Expressions.Expression expression)
{
var type = WrapperUtilities.GetTypeFromCache("System.Linq.IQueryProvider", "System.Core", TypeCache);
var methodInfo = WrapperUtilities.GetMethodInfo(type, MethodInfoCache, "System.Object Execute(System.Linq.Expressions.Expression)");
return(WrapperUtilities.InvokeMethodAndCast <object>(this, methodInfo, new object[] { expression }));
}
protected void wrapOidTest(
string[] oids,
string name)
{
byte[] data = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 };
for (int i = 0; i != oids.Length; i++)
{
IWrapper c1 = WrapperUtilities.GetWrapper(oids[i]);
IWrapper c2 = WrapperUtilities.GetWrapper(name);
CipherKeyGenerator kg = GeneratorUtilities.GetKeyGenerator(oids[i]);
KeyParameter k = ParameterUtilities.CreateKeyParameter(oids[i], kg.GenerateKey());
c1.Init(true, k);
c2.Init(false, k);
byte[] wrapped = c1.Wrap(data, 0, data.Length);
byte[] wKeyBytes = c2.Unwrap(wrapped, 0, wrapped.Length);
if (!AreEqual(data, wKeyBytes))
{
Fail("failed wrap OID test");
}
if (k.GetKey().Length != (16 + (i * 8)))
{
Fail("failed key length test");
}
}
}
/// <summary>
/// Wraps the 'Void WriteByte(Byte)' on the 'System.IO.Stream' type.
/// </summary>
/// <param name="value">The value of the 'value' parameter.</param>
public override void WriteByte(byte value)
{
var type = WrapperUtilities.GetTypeFromCache("System.IO.Stream", "mscorlib", TypeCache);
var methodInfo = WrapperUtilities.GetMethodInfo(type, MethodInfoCache, "Void WriteByte(Byte)");
WrapperUtilities.InvokeMethodWithoutResult(this, methodInfo, new object[] { value });
}
/// <summary>
/// Wraps the 'Int64 Seek(Int64, System.IO.SeekOrigin)' on the 'System.IO.Stream' type.
/// </summary>
/// <param name="offset">The value of the 'offset' parameter.</param>
/// <param name="origin">The value of the 'origin' parameter.</param>
/// <returns>The value returned by the underlying method.</returns>
public override long Seek(long offset, System.IO.SeekOrigin origin)
{
var type = WrapperUtilities.GetTypeFromCache("System.IO.Stream", "mscorlib", TypeCache);
var methodInfo = WrapperUtilities.GetMethodInfo(type, MethodInfoCache, "Int64 Seek(Int64, System.IO.SeekOrigin)");
return(WrapperUtilities.InvokeMethodAndCast <long>(this, methodInfo, new object[] { offset, origin }));
}
internal KeyParameter UnwrapKey(ICipherParameters key)
{
byte[] octets = this.info.EncryptedKey.GetOctets();
string exchangeEncryptionAlgorithmName = this.GetExchangeEncryptionAlgorithmName(this.keyEncAlg.ObjectID);
KeyParameter result;
try
{
IWrapper wrapper = WrapperUtilities.GetWrapper(exchangeEncryptionAlgorithmName);
wrapper.Init(false, key);
result = ParameterUtilities.CreateKeyParameter(base.GetContentAlgorithmName(), wrapper.Unwrap(octets, 0, octets.Length));
}
catch (SecurityUtilityException e)
{
throw new CmsException("couldn't create cipher.", e);
}
catch (InvalidKeyException e2)
{
throw new CmsException("key invalid in message.", e2);
}
catch (DataLengthException e3)
{
throw new CmsException("illegal blocksize in message.", e3);
}
catch (InvalidCipherTextException e4)
{
throw new CmsException("bad padding in message.", e4);
}
return(result);
}
/// <summary>
/// Wraps the 'Int32 ReadByte()' on the 'System.IO.Stream' type.
/// </summary>
/// <returns>The value returned by the underlying method.</returns>
public override int ReadByte()
{
var type = WrapperUtilities.GetTypeFromCache("System.IO.Stream", "mscorlib", TypeCache);
var methodInfo = WrapperUtilities.GetMethodInfo(type, MethodInfoCache, "Int32 ReadByte()");
return(WrapperUtilities.InvokeMethodAndCast <int>(this, methodInfo, new object[] { }));
}
/// <summary>
/// Wraps the 'Int32 Read(Byte[], Int32, Int32)' on the 'System.IO.Stream' type.
/// </summary>
/// <param name="buffer">The value of the 'buffer' parameter.</param>
/// <param name="offset">The value of the 'offset' parameter.</param>
/// <param name="count">The value of the 'count' parameter.</param>
/// <returns>The value returned by the underlying method.</returns>
public override int Read(byte[] buffer, int offset, int count)
{
var type = WrapperUtilities.GetTypeFromCache("System.IO.Stream", "mscorlib", TypeCache);
var methodInfo = WrapperUtilities.GetMethodInfo(type, MethodInfoCache, "Int32 Read(Byte[], Int32, Int32)");
return(WrapperUtilities.InvokeMethodAndCast <int>(this, methodInfo, new object[] { buffer, offset, count }));
}
/// <summary>
/// Wraps the 'Boolean Equals(System.Object)' on the 'System.IO.Stream' type.
/// </summary>
/// <param name="obj">The value of the 'obj' parameter.</param>
/// <returns>The value returned by the underlying method.</returns>
public override bool Equals(object obj)
{
var type = WrapperUtilities.GetTypeFromCache("System.Object", "mscorlib", TypeCache);
var methodInfo = WrapperUtilities.GetMethodInfo(type, MethodInfoCache, "Boolean Equals(System.Object)");
return(WrapperUtilities.InvokeMethodAndCast <bool>(this, methodInfo, new object[] { obj }));
}
/// <summary>
/// Wraps the 'Void EndWrite(System.IAsyncResult)' on the 'System.IO.Stream' type.
/// </summary>
/// <param name="asyncResult">The value of the 'asyncResult' parameter.</param>
public override void EndWrite(System.IAsyncResult asyncResult)
{
var type = WrapperUtilities.GetTypeFromCache("System.IO.Stream", "mscorlib", TypeCache);
var methodInfo = WrapperUtilities.GetMethodInfo(type, MethodInfoCache, "Void EndWrite(System.IAsyncResult)");
WrapperUtilities.InvokeMethodWithoutResult(this, methodInfo, new object[] { asyncResult });
}
/// <summary>
/// Wraps the 'Void CopyTo(T[], Int32)' on the 'System.Collections.ObjectModel.ReadOnlyCollection`1' type.
/// </summary>
/// <param name="array">The value of the 'array' parameter.</param>
/// <param name="index">The value of the 'index' parameter.</param>
public virtual void CopyTo(WrappedArray <T> array, int index)
{
#if !WINDOWS_PHONE
WrapperUtilities.InvokeMethodWithoutResult(this, WrapperUtilities.GetMethodInfo(WrappedObjectType, MethodInfoCache, "Void CopyTo(T[], Int32)"), new object[] { array, index });
#else
WrapperUtilities.InvokeMethodWithoutResult(this, WrapperUtilities.GetMethodInfo(WrappedObjectType, MethodInfoCache, "System.Void CopyTo(T[], System.Int32)"), new object[] { array, index });
#endif
}
/// <summary>
/// Wraps the 'Boolean Contains(T)' on the 'System.Collections.ObjectModel.ReadOnlyCollection`1' type.
/// </summary>
/// <param name="value">The value of the 'value' parameter.</param>
/// <returns>The value returned by the underlying method.</returns>
public virtual bool Contains(T value)
{
#if !WINDOWS_PHONE
return(WrapperUtilities.InvokeMethodAndCast <bool>(this, WrapperUtilities.GetMethodInfo(WrappedObjectType, MethodInfoCache, "Boolean Contains(T)"), new object[] { value }));
#else
return(WrapperUtilities.InvokeMethodAndCast <bool>(this, WrapperUtilities.GetMethodInfo(WrappedObjectType, MethodInfoCache, "System.Boolean Contains(T)"), new object[] { value }));
#endif
}
/// <summary>
/// Wraps the 'Int32 IndexOf(T)' on the 'System.Collections.ObjectModel.ReadOnlyCollection`1' type.
/// </summary>
/// <param name="value">The value of the 'value' parameter.</param>
/// <returns>The value returned by the underlying method.</returns>
public virtual int IndexOf(T value)
{
#if !WINDOWS_PHONE
return(WrapperUtilities.InvokeMethodAndCast <int>(this, WrapperUtilities.GetMethodInfo(WrappedObjectType, MethodInfoCache, "Int32 IndexOf(T)"), new object[] { value }));
#else
return(WrapperUtilities.InvokeMethodAndCast <int>(this, WrapperUtilities.GetMethodInfo(WrappedObjectType, MethodInfoCache, "System.Int32 IndexOf(T)"), new object[] { value }));
#endif
}
/// <summary>
/// Wraps the 'Void Close()' on the 'System.IO.Stream' type.
/// </summary>
public override void Close()
{
var type = WrapperUtilities.GetTypeFromCache("System.IO.Stream", "mscorlib", TypeCache);
var methodInfo = WrapperUtilities.GetMethodInfo(type, MethodInfoCache, "Void Close()");
WrapperUtilities.InvokeMethodWithoutResult(this, methodInfo, new object[] { });
this.Dispose(true);
}
/// <summary>
/// Wraps the 'Tasks.Task`int WriteAsync(Byte[], Int32, Int32, CancellationToken)' on the 'System.IO.Stream' type.
/// </summary>
/// <param name="buffer">The value of the 'buffer' parameter.</param>
/// <param name="offset">The value of the 'offset' parameter.</param>
/// <param name="count">The value of the 'count' parameter.</param>
/// <param name="cancellationToken">The value of the 'cancellationToken' parameter.</param>
/// <returns>The value returned by the underlying method.</returns>
public override Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
{
// this method has been added manually - WrapperGenerator will not be able to produce this
var type = WrapperUtilities.GetTypeFromCache("System.IO.Stream", "mscorlib", TypeCache);
var methodInfo = WrapperUtilities.GetMethodInfo(type, MethodInfoCache, "System.Threading.Tasks.Task WriteAsync(Byte[], Int32, Int32, System.Threading.CancellationToken)");
return(WrapperUtilities.InvokeMethodAndCast <Task>(this, methodInfo, new object[] { buffer, offset, count, cancellationToken }));
}
private KeyParameter UnwrapSessionKey(string wrapAlg, KeyParameter agreedKey)
{
byte[] octets = this.encryptedKey.GetOctets();
IWrapper wrapper = WrapperUtilities.GetWrapper(wrapAlg);
wrapper.Init(false, agreedKey);
byte[] keyBytes = wrapper.Unwrap(octets, 0, octets.Length);
return(ParameterUtilities.CreateKeyParameter(base.GetContentAlgorithmName(), keyBytes));
}
/// <summary>
/// Gets the MethodHandle based on the given signature
/// </summary>
/// <param name="type">The type where the method is</param>
/// <param name="methodInfoCache">The cache of method infos</param>
/// <param name="signature">The signature of the method to look up</param>
/// <returns>Runtime method handle.</returns>
public static MethodInfo GetMethodInfo(Type type, IDictionary <string, MethodInfo> methodInfoCache, string signature)
{
if (PlatformMethodMap.ContainsKey(signature))
{
signature = PlatformMethodMap[signature];
}
return(WrapperUtilities.GetMethodInfo(type, methodInfoCache, signature));
}
private void wrapTest(
string alg,
int id,
byte[] kek,
byte[] iv,
byte[] input,
byte[] output)
{
try
{
IWrapper wrapper = WrapperUtilities.GetWrapper(alg + "Wrap");
KeyParameter desEdeKey = new DesEdeParameters(kek);
wrapper.Init(true, new ParametersWithIV(desEdeKey, iv));
try
{
// byte[] cText = wrapper.Wrap(new SecretKeySpec(input, alg));
byte[] cText = wrapper.Wrap(input, 0, input.Length);
if (!Arrays.AreEqual(cText, output))
{
Fail("failed wrap test " + id + " expected "
+ Hex.ToHexString(output) + " got " + Hex.ToHexString(cText));
}
}
catch (Exception e)
{
Fail("failed wrap test exception " + e.ToString());
}
wrapper.Init(false, desEdeKey);
try
{
// Key pText = wrapper.unwrap(output, alg, IBufferedCipher.SECRET_KEY);
byte[] pText = wrapper.Unwrap(output, 0, output.Length);
// if (!Arrays.AreEqual(pText.getEncoded(), input))
if (!Arrays.AreEqual(pText, input))
{
Fail("failed unwrap test " + id + " expected "
+ Hex.ToHexString(input) + " got "
+ Hex.ToHexString(pText));
}
}
catch (Exception e)
{
Fail("failed unwrap test exception " + e.ToString());
}
}
catch (Exception ex)
{
Fail("failed exception " + ex.ToString());
}
}
/// <summary>
/// Gets a value of the 'Item' property on 'System.Collections.ObjectModel.ReadOnlyCollection`1'
/// </summary>
/// <param name="index">The value of the 'index' parameter.</param>
public virtual T this[int index]
{
get
{
#if !WINDOWS_PHONE
return(WrapperUtilities.InvokeMethodAndWrap <T>(this, WrapperUtilities.GetMethodInfo(WrappedObjectType, MethodInfoCache, "T get_Item(Int32)"), new object[] { index }));
#else
return(WrapperUtilities.InvokeMethodAndWrap <T>(this, WrapperUtilities.GetMethodInfo(WrappedObjectType, MethodInfoCache, "T get_Item(System.Int32)"), new object[] { index }));
#endif
}
}
