diff --git a/BaseApp/COD3000.TXT b/BaseApp/COD3000.TXT
index c8080a4..180487b 100644
--- a/BaseApp/COD3000.TXT
+++ b/BaseApp/COD3000.TXT
@@ -18,99 +18,132 @@ OBJECT Codeunit 3000 DotNet_Array
       DotNetArray@1000 : DotNet "'mscorlib'.System.Array";
 
     [External]
+    [LineStart(2)]
     PROCEDURE StringArray@108(Length@1000 : Integer);
     VAR
       DotNetString@1002 : DotNet "'mscorlib'.System.String";
     BEGIN
-      DotNetArray := DotNetArray.CreateInstance(GETDOTNETTYPE(DotNetString),Length);
+      DotNetArray := DotNetArray.CreateInstance(GetDotNetType(DotNetString),Length);
     END;
 
     [External]
+    [LineStart(5)]
     PROCEDURE CharArray@100(Length@1000 : Integer);
     VAR
       DotNetChar@1002 : DotNet "'mscorlib'.System.Char";
     BEGIN
-      DotNetArray := DotNetArray.CreateInstance(GETDOTNETTYPE(DotNetChar),Length);
+      DotNetArray := DotNetArray.CreateInstance(GetDotNetType(DotNetChar),Length);
     END;
 
     [External]
+    [LineStart(8)]
     PROCEDURE ByteArray@101(Length@1000 : Integer);
     VAR
       DotNetByte@1002 : DotNet "'mscorlib'.System.Byte";
     BEGIN
-      DotNetArray := DotNetArray.CreateInstance(GETDOTNETTYPE(DotNetByte),Length);
+      DotNetArray := DotNetArray.CreateInstance(GetDotNetType(DotNetByte),Length);
     END;
 
     [External]
+    [LineStart(11)]
     PROCEDURE Int32Array@102(Length@1000 : Integer);
     VAR
       DotNetInt32@1002 : DotNet "'mscorlib'.System.Int32";
     BEGIN
-      DotNetArray := DotNetArray.CreateInstance(GETDOTNETTYPE(DotNetInt32),Length);
+      DotNetArray := DotNetArray.CreateInstance(GetDotNetType(DotNetInt32),Length);
     END;
 
     [External]
+    [LineStart(14)]
     PROCEDURE Length@4() : Integer;
     BEGIN
-      EXIT(DotNetArray.Length)
+      exit(DotNetArray.Length)
     END;
 
     [External]
+    [LineStart(17)]
     PROCEDURE SetTextValue@103(NewValue@1001 : Text;Index@1000 : Integer);
     BEGIN
       DotNetArray.SetValue(NewValue,Index);
     END;
 
     [External]
+    [LineStart(20)]
     PROCEDURE SetCharValue@109(NewValue@1001 : Char;Index@1000 : Integer);
     BEGIN
       DotNetArray.SetValue(NewValue,Index);
     END;
 
     [External]
+    [LineStart(23)]
     PROCEDURE SetByteValue@104(NewValue@1001 : Byte;Index@1000 : Integer);
     BEGIN
       DotNetArray.SetValue(NewValue,Index);
     END;
 
     [External]
+    [LineStart(26)]
     PROCEDURE SetIntValue@105(NewValue@1001 : Integer;Index@1000 : Integer);
     BEGIN
       DotNetArray.SetValue(NewValue,Index);
     END;
 
     [External]
+    [LineStart(29)]
     PROCEDURE GetValueAsText@5(Index@1000 : Integer) : Text;
     BEGIN
-      EXIT(DotNetArray.GetValue(Index))
+      exit(DotNetArray.GetValue(Index))
     END;
 
     [External]
+    [LineStart(32)]
     PROCEDURE GetValueAsChar@110(Index@1000 : Integer) : Char;
     BEGIN
-      EXIT(DotNetArray.GetValue(Index));
+      exit(DotNetArray.GetValue(Index));
     END;
 
     [External]
+    [LineStart(35)]
     PROCEDURE GetValueAsInteger@106(Index@1000 : Integer) : Integer;
     BEGIN
-      EXIT(DotNetArray.GetValue(Index));
+      exit(DotNetArray.GetValue(Index));
     END;
 
+    [LineStart(38)]
     PROCEDURE GetArray@2(VAR DotNetArray2@1000 : DotNet "'mscorlib'.System.Array");
     BEGIN
       DotNetArray2 := DotNetArray
     END;
 
+    [LineStart(41)]
     PROCEDURE SetArray@3(DotNetArray2@1000 : DotNet "'mscorlib'.System.Array");
     BEGIN
       DotNetArray := DotNetArray2
     END;
 
     [External]
+    [LineStart(44)]
     PROCEDURE IsNull@107() : Boolean;
     BEGIN
-      EXIT(ISNULL(DotNetArray));
+      exit(IsNull(DotNetArray));
+    END;
+
+    [External]
+    [LineStart(47)]
+    PROCEDURE Clone@1000000001(VAR DotNet_ArrayTarget@1000000000 : Codeunit DotNet_Array);
+    BEGIN
+      DotNet_ArrayTarget.SetArray(DotNetArray.Clone());
+    END;
+
+    [External]
+    [LineStart(50)]
+    PROCEDURE ConstrainedCopy@1000000000(SourceIndex@1000000001 : Integer;VAR DotNet_ArrayTarget@1000000002 : Codeunit DotNet_Array;TargetIndex@1000000003 : Integer;Length@1000000004 : Integer);
+    VAR
+      DotNetArrayTarget@1000000006 : DotNet "'mscorlib'.System.Array";
+    BEGIN
+      DotNet_ArrayTarget.GetArray(DotNetArrayTarget);
+      DotNetArray.ConstrainedCopy(DotNetArray, SourceIndex, DotNetArrayTarget, TargetIndex, Length);
+      DotNet_ArrayTarget.SetArray(DotNetArrayTarget);
     END;
 
     BEGIN
diff --git a/BaseApp/COD3025.TXT b/BaseApp/COD3025.TXT
index 3fb5a34..53babf4 100644
--- a/BaseApp/COD3025.TXT
+++ b/BaseApp/COD3025.TXT
@@ -38,6 +38,17 @@ OBJECT Codeunit 3025 DotNet_StreamWriter
       DotNetStreamWriter := DotNetStreamWriter.StreamWriter(OutStream,DotNetEncoding);
     END;
 
+    [External]
+    PROCEDURE StreamWriterFromDotNetStream@1000000001(VAR DotNet_Stream@1000 : Codeunit 3034;DotNet_Encoding@1001 : Codeunit 3026);
+    VAR
+      DotNetEncoding@1002 : DotNet "'mscorlib'.System.Text.Encoding";
+      DotNetStream@1000000000 : DotNet "'mscorlib'.System.IO.Stream";
+    BEGIN
+      DotNet_Stream.GetStream(DotNetStream);
+      DotNet_Encoding.GetEncoding(DotNetEncoding);
+      DotNetStreamWriter := DotNetStreamWriter.StreamWriter(DotNetStream,DotNetEncoding);
+    END;
+
     [External]
     PROCEDURE StreamWriterWithDefaultEncoding@7(VAR OutStream@1000 : OutStream);
     BEGIN
@@ -62,6 +73,16 @@ OBJECT Codeunit 3025 DotNet_StreamWriter
       DotNetStreamWriter.Dispose;
     END;
 
+    PROCEDURE GetStreamWriter@1000000000(VAR DotNetStreamWriter2@1000000000 : DotNet "'mscorlib'.System.IO.StreamWriter");
+    BEGIN
+      DotNetStreamWriter2 := DotNetStreamWriter;
+    END;
+
+    PROCEDURE SetStreamWriter@1000000002(VAR DotNetStreamWriter2@1000000000 : DotNet "'mscorlib'.System.IO.StreamWriter");
+    BEGIN
+      DotNetStreamWriter := DotNetStreamWriter2;
+    END;
+
     BEGIN
     END.
   }
diff --git a/BaseApp/COD3027.TXT b/BaseApp/COD3027.TXT
index 4e5f7f7..52e7657 100644
--- a/BaseApp/COD3027.TXT
+++ b/BaseApp/COD3027.TXT
@@ -26,6 +26,18 @@ OBJECT Codeunit 3027 DotNet_StreamReader
       DotNetStreamReader := DotNetStreamReader.StreamReader(InputStream,DotNetEncoding);
     END;
 
+    [External]
+    PROCEDURE StreamReaderFromDotNetStream@1000000000(VAR DotNet_Stream@1000 : Codeunit 3034;DotNet_Encoding@1001 : Codeunit 3026);
+    VAR
+      DotNetEncoding@1002 : DotNet "'mscorlib'.System.Text.Encoding";
+      DotNetStream@1000000000 : DotNet "'mscorlib'.System.IO.Stream";
+    BEGIN
+      DotNet_Stream.GetStream(DotNetStream);
+      DotNet_Encoding.GetEncoding(DotNetEncoding);
+
+      DotNetStreamReader := DotNetStreamReader.StreamReader(DotNetStream,DotNetEncoding);
+    END;
+
     [External]
     PROCEDURE StreamReaderDetectEncoding@2(VAR InputStream@1000 : InStream;DetectEncodingFromByteOrderMarks@1001 : Boolean);
     BEGIN
@@ -68,6 +80,16 @@ OBJECT Codeunit 3027 DotNet_StreamReader
       EXIT(DotNetStreamReader.ReadToEnd);
     END;
 
+    PROCEDURE GetStreamReader@1000000001(VAR DotNetStreamReader2@1000000000 : DotNet "'mscorlib'.System.IO.StreamReader");
+    BEGIN
+      DotNetStreamReader2 := DotNetStreamReader;
+    END;
+
+    PROCEDURE SetStreamReader@1000000002(VAR DotNetStreamReader2@1000000000 : DotNet "'mscorlib'.System.IO.StreamReader");
+    BEGIN
+      DotNetStreamReader := DotNetStreamReader2;
+    END;
+
     BEGIN
     END.
   }
diff --git a/BaseApp/COD50010.TXT b/BaseApp/COD50010.TXT
new file mode 100644
index 0000000..6bd6c04
--- /dev/null
+++ b/BaseApp/COD50010.TXT
@@ -0,0 +1,181 @@
+OBJECT Codeunit 50010 DotNet_SymmetricAlgorithm
+{
+  OBJECT-PROPERTIES
+  {
+    Date=;
+    Time=;
+    Version List=;
+  }
+  PROPERTIES
+  {
+    OnRun=BEGIN
+          END;
+
+  }
+  CODE
+  {
+    VAR
+      DotNetSymmetricAlgorithm@1000000000 : DotNet "'mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089'.System.Security.Cryptography.SymmetricAlgorithm";
+      E_INVALID_ALGORITHM@1000000001 : TextConst 'ENU=Invalid Algorithm';
+
+    [External]
+    PROCEDURE GetBlockSize@1000000000() : Integer;
+    BEGIN
+      EXIT(DotNetSymmetricAlgorithm.BlockSize);
+    END;
+
+    [External]
+    PROCEDURE SetBlockSize@1000000027(BlockSize@1000000000 : Integer);
+    BEGIN
+      DotNetSymmetricAlgorithm.BlockSize := BlockSize;
+    END;
+
+    [External]
+    PROCEDURE GetFeedbackSize@1000000007() : Integer;
+    BEGIN
+      EXIT(DotNetSymmetricAlgorithm.FeedbackSize);
+    END;
+
+    [External]
+    PROCEDURE SetFeedbackSize@1000000006(FeedbackSize@1000000000 : Integer);
+    BEGIN
+      DotNetSymmetricAlgorithm.FeedbackSize := FeedbackSize;
+    END;
+
+    [External]
+    PROCEDURE GetIV@1000000001(VAR DotNet_Array@1000000000 : Codeunit 3000);
+    VAR
+      DotNetArray@1000000001 : DotNet "'mscorlib'.System.Array";
+    BEGIN
+      DotNet_Array.GetArray(DotNetArray);
+      DotNetArray := DotNetSymmetricAlgorithm.IV.Clone();
+      DotNet_Array.SetArray(DotNetArray);
+    END;
+
+    [External]
+    PROCEDURE SetIV@1000000023(VAR DotNet_Array@1000000000 : Codeunit 3000);
+    VAR
+      DotNetArray@1000000001 : DotNet "'mscorlib'.System.Array";
+    BEGIN
+      DotNet_Array.GetArray(DotNetArray);
+      DotNetSymmetricAlgorithm.IV := DotNetArray.Clone();
+    END;
+
+    [External]
+    PROCEDURE GetKey@1000000002(VAR DotNet_Array@1000000000 : Codeunit 3000);
+    VAR
+      DotNetArray@1000000001 : DotNet "'mscorlib'.System.Array";
+    BEGIN
+      DotNet_Array.GetArray(DotNetArray);
+      DotNetArray := DotNetSymmetricAlgorithm.Key.Clone();
+      DotNet_Array.SetArray(DotNetArray);
+    END;
+
+    [External]
+    PROCEDURE SetKey@1000000021(VAR DotNet_Array@1000000000 : Codeunit 3000);
+    VAR
+      DotNetArray@1000000001 : DotNet "'mscorlib'.System.Array";
+    BEGIN
+      DotNet_Array.GetArray(DotNetArray);
+      DotNetSymmetricAlgorithm.Key := DotNetArray.Clone();
+    END;
+
+    [External]
+    PROCEDURE GetKeySize@1000000003() : Integer;
+    BEGIN
+      EXIT(DotNetSymmetricAlgorithm.KeySize);
+    END;
+
+    [External]
+    PROCEDURE SetKeySize@1000000018(KeySize@1000000000 : Integer);
+    BEGIN
+      DotNetSymmetricAlgorithm.KeySize := KeySize;
+    END;
+
+    [External]
+    PROCEDURE GetMode@1000000004(VAR DotNet_CipherMode@1000000000 : Codeunit 50015) : Integer;
+    VAR
+      DotNetCipherMode@1000000001 : DotNet "'mscorlib'.System.Security.Cryptography.CipherMode";
+    BEGIN
+      DotNetCipherMode := DotNetSymmetricAlgorithm.Mode;
+      DotNet_CipherMode.SetCipherMode(DotNetCipherMode);
+      EXIT(DotNetCipherMode);
+    END;
+
+    [External]
+    PROCEDURE SetMode@1000000020(VAR DotNet_CipherMode@1000000000 : Codeunit 50015);
+    VAR
+      DotNetCipherMode@1000000001 : DotNet "'mscorlib'.System.Security.Cryptography.CipherMode";
+    BEGIN
+      DotNet_CipherMode.GetCipherMode(DotNetCipherMode);
+      DotNetSymmetricAlgorithm.Mode := DotNetCipherMode;
+    END;
+
+    [External]
+    PROCEDURE GetPadding@1000000005(VAR DotNet_PaddingMode@1000000001 : Codeunit 50016) : Integer;
+    VAR
+      DotNetPaddingMode@1000000000 : DotNet "'mscorlib'.System.Security.Cryptography.PaddingMode";
+    BEGIN
+      DotNetPaddingMode := DotNetSymmetricAlgorithm.Padding;
+      DotNet_PaddingMode.SetPaddingMode(DotNetPaddingMode);
+      EXIT(DotNetPaddingMode);
+    END;
+
+    [External]
+    PROCEDURE SetPadding@1000000019(VAR DotNet_PaddingMode@1000000002 : Codeunit 50016);
+    VAR
+      DotNetPaddingMode@1000000001 : DotNet "'mscorlib'.System.Security.Cryptography.PaddingMode";
+    BEGIN
+      DotNet_PaddingMode.GetPaddingMode(DotNetPaddingMode);
+      DotNetSymmetricAlgorithm.Padding := DotNetPaddingMode;
+    END;
+
+    [External]
+    PROCEDURE Create@1000000028(Algorithm@1000000000 : Text);
+    BEGIN
+      IF NOT (UPPERCASE(Algorithm) IN ['AES','DES','RC2','RIJNDAEL','TRIPLEDES']) THEN
+        ERROR(E_INVALID_ALGORITHM);
+      Dispose();
+      DotNetSymmetricAlgorithm := DotNetSymmetricAlgorithm.Create(Algorithm);
+    END;
+
+    [External]
+    PROCEDURE Dispose@1000000008();
+    BEGIN
+      IF NOT ISNULL(DotNetSymmetricAlgorithm) THEN
+        DotNetSymmetricAlgorithm.Dispose();
+    END;
+
+    [External]
+    PROCEDURE CreateEncryptor@1000000009(VAR DotNet_ICryptoTransform@1000000000 : Codeunit 50013);
+    VAR
+      DotNetICryptoTransform@1000000001 : DotNet "'mscorlib'.System.Security.Cryptography.ICryptoTransform";
+    BEGIN
+      DotNetICryptoTransform := DotNetSymmetricAlgorithm.CreateEncryptor();
+      DotNet_ICryptoTransform.SetICryptoTransform(DotNetICryptoTransform);
+    END;
+
+    [External]
+    PROCEDURE CreateDecryptor@1000000015(VAR DotNet_ICryptoTransform@1000000000 : Codeunit 50013);
+    VAR
+      DotNetICryptoTransform@1000000001 : DotNet "'mscorlib'.System.Security.Cryptography.ICryptoTransform";
+    BEGIN
+      DotNetICryptoTransform := DotNetSymmetricAlgorithm.CreateDecryptor();
+      DotNet_ICryptoTransform.SetICryptoTransform(DotNetICryptoTransform);
+    END;
+
+    PROCEDURE GetSymmetricAlgorithm@1000000013(VAR DotNetSymmetricAlgorithm2@1000000000 : DotNet "'mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089'.System.Security.Cryptography.SymmetricAlgorithm");
+    BEGIN
+      DotNetSymmetricAlgorithm2 := DotNetSymmetricAlgorithm;
+    END;
+
+    PROCEDURE SetSymmetricAlgorithm@1000000014(VAR DotNetSymmetricAlgorithm2@1000000000 : DotNet "'mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089'.System.Security.Cryptography.SymmetricAlgorithm");
+    BEGIN
+      DotNetSymmetricAlgorithm := DotNetSymmetricAlgorithm2;
+    END;
+
+    BEGIN
+    END.
+  }
+}
+
diff --git a/BaseApp/COD50012.TXT b/BaseApp/COD50012.TXT
new file mode 100644
index 0000000..377d7c6
--- /dev/null
+++ b/BaseApp/COD50012.TXT
@@ -0,0 +1,77 @@
+OBJECT Codeunit 50012 DotNet_HashAlgorithm
+{
+  OBJECT-PROPERTIES
+  {
+    Date=;
+    Time=;
+    Version List=;
+  }
+  PROPERTIES
+  {
+    OnRun=BEGIN
+          END;
+
+  }
+  CODE
+  {
+    VAR
+      DotNetHashAlgorithm@1000000000 : DotNet "'mscorlib'.System.Security.Cryptography.HashAlgorithm";
+      EALGORITHM@1000000001 : TextConst 'ENU=Invalid Hash Algorithm';
+
+    [External]
+    PROCEDURE Create@1000000005(HashAlgorithm@1000000000 : Text);
+    BEGIN
+      IF NOT (UPPERCASE(HashAlgorithm) IN ['SHA1','MD5','SHA256','SHA384','SHA512']) THEN
+        ERROR(EALGORITHM);
+      DotNetHashAlgorithm := DotNetHashAlgorithm.Create(HashAlgorithm);
+    END;
+
+    [External]
+    PROCEDURE ComputeHash@1000000001(VAR DotNet_ArrayData@1000000001 : Codeunit 3000;VAR DotNet_ArrayHash@1000 : Codeunit 3000);
+    VAR
+      DotNetArray@1000000000 : DotNet "'mscorlib'.System.Array";
+    BEGIN
+      DotNet_ArrayData.GetArray(DotNetArray);
+      DotNet_ArrayHash.SetArray(DotNetHashAlgorithm.ComputeHash(DotNetArray));
+    END;
+
+    [External]
+    PROCEDURE ComputeHashFromText@1000000000(VAR Text@1000000001 : Text;VAR DotNet_Array@1000 : Codeunit 3000);
+    VAR
+      DotNetEncoding@1000000002 : DotNet "'mscorlib'.System.Text.Encoding";
+      DotNet_Encoding@1000000003 : Codeunit 3026;
+    BEGIN
+      IF Text = '' THEN
+        EXIT;
+      DotNet_Encoding.UTF8;
+      DotNet_Encoding.GetEncoding(DotNetEncoding);
+      DotNet_Array.SetArray(DotNetHashAlgorithm.ComputeHash(DotNetEncoding.GetBytes(Text)));
+    END;
+
+    [External]
+    PROCEDURE ComputeHashFromInStream@5(VAR IStream@1000000001 : InStream;VAR DotNet_Array@1000 : Codeunit 3000);
+    BEGIN
+      DotNet_Array.SetArray(DotNetHashAlgorithm.ComputeHash(IStream));
+    END;
+
+    [External]
+    PROCEDURE Dispose@1000000006();
+    BEGIN
+      DotNetHashAlgorithm.Dispose();
+    END;
+
+    PROCEDURE GetHashAlgorithm@2(VAR DotNetHashAlgorithm2@1000000001 : DotNet "'mscorlib'.System.Security.Cryptography.HashAlgorithm");
+    BEGIN
+      DotNetHashAlgorithm2 := DotNetHashAlgorithm;
+    END;
+
+    PROCEDURE SetHashAlgorithm@3(VAR DotNetHashAlgorithm2@1000000000 : DotNet "'mscorlib'.System.Security.Cryptography.HashAlgorithm");
+    BEGIN
+      DotNetHashAlgorithm := DotNetHashAlgorithm2;
+    END;
+
+    BEGIN
+    END.
+  }
+}
+
diff --git a/BaseApp/COD50013.TXT b/BaseApp/COD50013.TXT
new file mode 100644
index 0000000..221e63b
--- /dev/null
+++ b/BaseApp/COD50013.TXT
@@ -0,0 +1,40 @@
+OBJECT Codeunit 50013 DotNet_ICryptoTransform
+{
+  OBJECT-PROPERTIES
+  {
+    Date=;
+    Time=;
+    Version List=;
+  }
+  PROPERTIES
+  {
+    OnRun=BEGIN
+          END;
+
+  }
+  CODE
+  {
+    VAR
+      DotNetICryptoTransform@1000000000 : DotNet "'mscorlib'.System.Security.Cryptography.ICryptoTransform";
+
+    [External]
+    PROCEDURE Dispose@1000000006();
+    BEGIN
+      DotNetICryptoTransform.Dispose()
+    END;
+
+    PROCEDURE GetICryptoTransform@2(VAR DotNetICryptoTransform2@1000000001 : DotNet "'mscorlib'.System.Security.Cryptography.ICryptoTransform");
+    BEGIN
+      DotNetICryptoTransform2 := DotNetICryptoTransform
+    END;
+
+    PROCEDURE SetICryptoTransform@3(VAR DotNetICryptoTransform2@1000000000 : DotNet "'mscorlib'.System.Security.Cryptography.ICryptoTransform");
+    BEGIN
+      DotNetICryptoTransform := DotNetICryptoTransform2
+    END;
+
+    BEGIN
+    END.
+  }
+}
+
diff --git a/BaseApp/COD50014.TXT b/BaseApp/COD50014.TXT
new file mode 100644
index 0000000..4cb763e
--- /dev/null
+++ b/BaseApp/COD50014.TXT
@@ -0,0 +1,113 @@
+OBJECT Codeunit 50014 DotNet_CryptoStream
+{
+  OBJECT-PROPERTIES
+  {
+    Date=;
+    Time=;
+    Version List=;
+  }
+  PROPERTIES
+  {
+    OnRun=BEGIN
+          END;
+
+  }
+  CODE
+  {
+    VAR
+      DotNetCryptoStream@1000000000 : DotNet "'mscorlib'.System.Security.Cryptography.CryptoStream";
+
+    [External]
+    PROCEDURE CryptoStream@1000000001(VAR DotNet_Stream@1000000000 : Codeunit 3034;VAR DotNet_ICryptoTransform@1000000001 : Codeunit 50013;VAR DotNet_CryptoStreamMode@1000000005 : Codeunit 50017);
+    VAR
+      DotNetStream@1000000002 : DotNet "'mscorlib'.System.IO.Stream";
+      DotNetICryptoTransform@1000000004 : DotNet "'mscorlib'.System.Security.Cryptography.ICryptoTransform";
+      DotNetCryptoStreamMode@1000000003 : DotNet "'mscorlib'.System.Security.Cryptography.CryptoStreamMode";
+    BEGIN
+      DotNet_Stream.GetStream(DotNetStream);
+      DotNet_ICryptoTransform.GetICryptoTransform(DotNetICryptoTransform);
+      DotNet_CryptoStreamMode.GetCryptoStreamMode(DotNetCryptoStreamMode);
+      DotNetCryptoStream := DotNetCryptoStream.CryptoStream(DotNetStream, DotNetICryptoTransform, DotNetCryptoStreamMode);
+    END;
+
+    [External]
+    PROCEDURE CryptoInStream@1000000005(IStream@1000000000 : InStream;VAR DotNet_ICryptoTransform@1000000001 : Codeunit 50013);
+    VAR
+      DotNetICryptoTransform@1000000004 : DotNet "'mscorlib'.System.Security.Cryptography.ICryptoTransform";
+      DotNetCryptoStreamMode@1000000003 : DotNet "'mscorlib'.System.Security.Cryptography.CryptoStreamMode";
+    BEGIN
+      DotNet_ICryptoTransform.GetICryptoTransform(DotNetICryptoTransform);
+      DotNetCryptoStream := DotNetCryptoStream.CryptoStream(IStream, DotNetICryptoTransform, DotNetCryptoStreamMode.Read);
+    END;
+
+    [External]
+    PROCEDURE CryptoOutStream@1000000000(OStream@1000000000 : OutStream;VAR DotNet_ICryptoTransform@1000000001 : Codeunit 50013);
+    VAR
+      DotNetICryptoTransform@1000000004 : DotNet "'mscorlib'.System.Security.Cryptography.ICryptoTransform";
+      DotNetCryptoStreamMode@1000000003 : DotNet "'mscorlib'.System.Security.Cryptography.CryptoStreamMode";
+    BEGIN
+      DotNet_ICryptoTransform.GetICryptoTransform(DotNetICryptoTransform);
+      DotNetCryptoStream := DotNetCryptoStream.CryptoStream(OStream, DotNetICryptoTransform, DotNetCryptoStreamMode.Write);
+    END;
+
+    [External]
+    PROCEDURE CanRead@1000000002() : Boolean;
+    BEGIN
+      IF NOT ISNULL(DotNetCryptoStream) THEN
+        EXIT(DotNetCryptoStream.CanRead);
+      EXIT(FALSE);
+    END;
+
+    [External]
+    PROCEDURE CanSeek@1000000003() : Boolean;
+    BEGIN
+      IF NOT ISNULL(DotNetCryptoStream) THEN
+        EXIT(DotNetCryptoStream.CanSeek);
+      EXIT(FALSE);
+    END;
+
+    [External]
+    PROCEDURE CanWrite@1000000004() : Boolean;
+    BEGIN
+      IF NOT ISNULL(DotNetCryptoStream) THEN
+        EXIT(DotNetCryptoStream.CanWrite);
+      EXIT(FALSE);
+    END;
+
+    [External]
+    PROCEDURE Length@1000000008() : Integer;
+    BEGIN
+      IF NOT ISNULL(DotNetCryptoStream) THEN
+        EXIT(DotNetCryptoStream.Length);
+      EXIT(0);
+    END;
+
+    [External]
+    PROCEDURE Position@1000000007() : Integer;
+    BEGIN
+      IF NOT ISNULL(DotNetCryptoStream) THEN
+        EXIT(DotNetCryptoStream.Position);
+      EXIT(0);
+    END;
+
+    [External]
+    PROCEDURE Dispose@1000000006();
+    BEGIN
+      DotNetCryptoStream.Dispose();
+    END;
+
+    PROCEDURE GetCryptoStream@2(VAR DotNetCryptoStream2@1000000000 : DotNet "'mscorlib'.System.Security.Cryptography.CryptoStream");
+    BEGIN
+      DotNetCryptoStream2 := DotNetCryptoStream;
+    END;
+
+    PROCEDURE SetCryptoStream@3(VAR DotNetCryptoStream2@1000000000 : DotNet "'mscorlib'.System.Security.Cryptography.CryptoStream");
+    BEGIN
+      DotNetCryptoStream := DotNetCryptoStream2;
+    END;
+
+    BEGIN
+    END.
+  }
+}
+
diff --git a/BaseApp/COD50015.TXT b/BaseApp/COD50015.TXT
new file mode 100644
index 0000000..8469b34
--- /dev/null
+++ b/BaseApp/COD50015.TXT
@@ -0,0 +1,78 @@
+OBJECT Codeunit 50015 DotNet_CipherMode
+{
+  OBJECT-PROPERTIES
+  {
+    Date=;
+    Time=;
+    Version List=;
+  }
+  PROPERTIES
+  {
+    OnRun=BEGIN
+          END;
+
+  }
+  CODE
+  {
+    VAR
+      DotNetCipherMode@1000000000 : DotNet "'mscorlib'.System.Security.Cryptography.CipherMode";
+
+    [External]
+    PROCEDURE CBC@1000000000() : Integer;
+    BEGIN
+      DotNetCipherMode := DotNetCipherMode.CBC;
+      EXIT(DotNetCipherMode);
+    END;
+
+    [External]
+    PROCEDURE ECB@1000000001() : Integer;
+    BEGIN
+      DotNetCipherMode := DotNetCipherMode.ECB;
+      EXIT(DotNetCipherMode);
+    END;
+
+    [External]
+    PROCEDURE OFB@1000000002() : Integer;
+    BEGIN
+      DotNetCipherMode := DotNetCipherMode.OFB;
+      EXIT(DotNetCipherMode);
+    END;
+
+    [External]
+    PROCEDURE CFB@1000000003() : Integer;
+    BEGIN
+      DotNetCipherMode := DotNetCipherMode.CFB;
+      EXIT(DotNetCipherMode);
+    END;
+
+    [External]
+    PROCEDURE CTS@1000000004() : Integer;
+    BEGIN
+      DotNetCipherMode := DotNetCipherMode.CTS;
+      EXIT(DotNetCipherMode);
+    END;
+
+    [External]
+    PROCEDURE Value@1000000005() : Integer;
+    VAR
+      Mode@1000000000 : Integer;
+    BEGIN
+      Mode := DotNetCipherMode;
+      EXIT(Mode);
+    END;
+
+    PROCEDURE GetCipherMode@1000000006(VAR DotNetCipherMode2@1000000000 : DotNet "'mscorlib'.System.Security.Cryptography.CipherMode");
+    BEGIN
+      DotNetCipherMode2 := DotNetCipherMode;
+    END;
+
+    PROCEDURE SetCipherMode@1000000007(VAR DotNetCipherMode2@1000000000 : DotNet "'mscorlib'.System.Security.Cryptography.CipherMode");
+    BEGIN
+      DotNetCipherMode := DotNetCipherMode2;
+    END;
+
+    BEGIN
+    END.
+  }
+}
+
diff --git a/BaseApp/COD50016.TXT b/BaseApp/COD50016.TXT
new file mode 100644
index 0000000..ac14a8e
--- /dev/null
+++ b/BaseApp/COD50016.TXT
@@ -0,0 +1,78 @@
+OBJECT Codeunit 50016 DotNet_PaddingMode
+{
+  OBJECT-PROPERTIES
+  {
+    Date=;
+    Time=;
+    Version List=;
+  }
+  PROPERTIES
+  {
+    OnRun=BEGIN
+          END;
+
+  }
+  CODE
+  {
+    VAR
+      DotNetPaddingMode@1000000000 : DotNet "'mscorlib'.System.Security.Cryptography.PaddingMode";
+
+    [External]
+    PROCEDURE None@1000000000() : Integer;
+    BEGIN
+      DotNetPaddingMode := DotNetPaddingMode.None;
+      EXIT(DotNetPaddingMode);
+    END;
+
+    [External]
+    PROCEDURE PKCS7@1000000001() : Integer;
+    BEGIN
+      DotNetPaddingMode := DotNetPaddingMode.PKCS7;
+      EXIT(DotNetPaddingMode);
+    END;
+
+    [External]
+    PROCEDURE Zeros@1000000002() : Integer;
+    BEGIN
+      DotNetPaddingMode := DotNetPaddingMode.Zeros;
+      EXIT(DotNetPaddingMode);
+    END;
+
+    [External]
+    PROCEDURE ANSIX923@1000000003() : Integer;
+    BEGIN
+      DotNetPaddingMode := DotNetPaddingMode.ANSIX923;
+      EXIT(DotNetPaddingMode);
+    END;
+
+    [External]
+    PROCEDURE ISO10126@1000000004() : Integer;
+    BEGIN
+      DotNetPaddingMode := DotNetPaddingMode.ISO10126;
+      EXIT(DotNetPaddingMode);
+    END;
+
+    [External]
+    PROCEDURE Value@1000000007() : Integer;
+    VAR
+      PaddingMode@1000000000 : Integer;
+    BEGIN
+      PaddingMode := DotNetPaddingMode;
+      EXIT(PaddingMode);
+    END;
+
+    PROCEDURE GetPaddingMode@1000000005(VAR DotNetPaddingMode2@1000000000 : DotNet "'mscorlib'.System.Security.Cryptography.PaddingMode");
+    BEGIN
+      DotNetPaddingMode2 := DotNetPaddingMode;
+    END;
+
+    PROCEDURE SetPaddingMode@1000000006(VAR DotNetPaddingMode2@1000000000 : DotNet "'mscorlib'.System.Security.Cryptography.PaddingMode");
+    BEGIN
+      DotNetPaddingMode := DotNetPaddingMode2;
+    END;
+
+    BEGIN
+    END.
+  }
+}
+
diff --git a/BaseApp/COD50017.TXT b/BaseApp/COD50017.TXT
new file mode 100644
index 0000000..e70951a
--- /dev/null
+++ b/BaseApp/COD50017.TXT
@@ -0,0 +1,48 @@
+OBJECT Codeunit 50017 DotNet_CryptoStreamMode
+{
+  OBJECT-PROPERTIES
+  {
+    Date=;
+    Time=;
+    Version List=;
+  }
+  PROPERTIES
+  {
+    OnRun=BEGIN
+          END;
+
+  }
+  CODE
+  {
+    VAR
+      DotNetCryptoStreamMode@1000000000 : DotNet "'mscorlib'.System.Security.Cryptography.CryptoStreamMode";
+
+    [External]
+    PROCEDURE Read@1000000000() : Integer;
+    BEGIN
+      DotNetCryptoStreamMode := DotNetCryptoStreamMode.Read;
+      EXIT(DotNetCryptoStreamMode);
+    END;
+
+    [External]
+    PROCEDURE Write@1000000001() : Integer;
+    BEGIN
+      DotNetCryptoStreamMode := DotNetCryptoStreamMode.Write;
+      EXIT(DotNetCryptoStreamMode);
+    END;
+
+    PROCEDURE GetCryptoStreamMode@1000000005(VAR DotNetCryptoStreamMode2@1000000000 : DotNet "'mscorlib'.System.Security.Cryptography.CryptoStreamMode");
+    BEGIN
+      DotNetCryptoStreamMode2 := DotNetCryptoStreamMode;
+    END;
+
+    PROCEDURE SetCryptoStreamMode@1000000006(VAR DotNetCryptoStreamMode2@1000000000 : DotNet "'mscorlib'.System.Security.Cryptography.CryptoStreamMode");
+    BEGIN
+      DotNetCryptoStreamMode := DotNetCryptoStreamMode2;
+    END;
+
+    BEGIN
+    END.
+  }
+}
+
diff --git a/BaseApp/COD50020.TXT b/BaseApp/COD50020.TXT
new file mode 100644
index 0000000..eaa3d9a
--- /dev/null
+++ b/BaseApp/COD50020.TXT
@@ -0,0 +1,493 @@
+OBJECT Codeunit 50020 Symmetric Encryption Mgt
+{
+  OBJECT-PROPERTIES
+  {
+    Date=;
+    Time=;
+    Version List=;
+  }
+  PROPERTIES
+  {
+    OnRun=BEGIN
+
+            // Helper Interface ======================================================================================
+          END;
+
+  }
+  CODE
+  {
+    VAR
+      KeySize@1000000001 : Integer;
+      BlockSize@1000000000 : Integer;
+      SymmetricAlgorithm@1000000003 : Text;
+      DotNetCipherMode@1000000002 : DotNet "'mscorlib'.System.Security.Cryptography.CipherMode";
+      DotNetPaddingMode@1000000005 : DotNet "'mscorlib'.System.Security.Cryptography.PaddingMode";
+      DotNet_ArrayKey@1000000008 : Codeunit 3000;
+      DotNet_ArrayIV@1000000007 : Codeunit 3000;
+      E_NO_CIPHER@1000000004 : TextConst 'ENU=SymmetricAlgorithm - cipher not defined';
+
+    [External]
+    PROCEDURE SetCipher@1000000015(VAR CipherText@1000000000 : Text);
+    VAR
+      TempBlob@1000000001 : Record 99008535;
+    BEGIN
+
+      // NOTE: Passing a cipher as plain text is not secure.
+      // For a more secure interface use the SetCipherFromBlob interface
+
+      IF CipherText = '' THEN
+        EXIT;
+
+      TempBlob.WriteAsText(CipherText, TEXTENCODING::UTF8);
+      IF TrySetCipher(TempBlob) THEN ;
+    END;
+
+    [External]
+    PROCEDURE SetCipherFromBlob@1000000014(VAR TempBlob@1000000000 : Record 99008535);
+    BEGIN
+
+      IF TrySetCipher(TempBlob) THEN ;
+    END;
+
+    [External]
+    PROCEDURE Base64ToPlainText@1000000053(Base64Text@1000000000 : Text) : Text;
+    VAR
+      DotNet_Encoding@1000000001 : Codeunit 3026;
+      DotNet_Convert@1000000002 : Codeunit 3008;
+      DotNetConvert@1000000004 : DotNet "'mscorlib'.System.Convert";
+      DotNetEncoding@1000000003 : DotNet "'mscorlib'.System.Text.Encoding";
+    BEGIN
+
+      IF Base64Text = '' THEN
+        EXIT('');
+
+      DotNet_Encoding.UTF8;
+      DotNet_Encoding.GetEncoding(DotNetEncoding);
+      DotNet_Convert.GetConvert(DotNetConvert);
+      EXIT(DotNetEncoding.GetString(DotNetConvert.FromBase64String(Base64Text)));
+
+      // Public Interface ======================================================================================
+    END;
+
+    [External]
+    PROCEDURE SetAlgorithm@1000000023(Algorithm@1000000000 : Text);
+    BEGIN
+
+      SymmetricAlgorithm := Algorithm;
+    END;
+
+    [External]
+    PROCEDURE SetKeySize@1000000021(Size@1000000000 : Integer);
+    BEGIN
+
+      KeySize := Size;
+    END;
+
+    [External]
+    PROCEDURE SetBlockSize@1000000022(Size@1000000000 : Integer);
+    BEGIN
+
+      BlockSize := Size;
+    END;
+
+    [External]
+    PROCEDURE SetMode@1000000024(VAR DotNet_CipherMode@1000000000 : Codeunit 50015);
+    BEGIN
+      DotNet_CipherMode.GetCipherMode(DotNetCipherMode);
+    END;
+
+    [External]
+    PROCEDURE SetPadding@1000000000(VAR DotNet_PaddingMode@1000000000 : Codeunit 50016);
+    BEGIN
+      DotNet_PaddingMode.GetPaddingMode(DotNetPaddingMode);
+    END;
+
+    [External]
+    PROCEDURE SetKey@1000000008(VAR DotNet_Array@1000000000 : Codeunit 3000);
+    BEGIN
+
+      DotNet_Array.Clone(DotNet_ArrayKey);
+    END;
+
+    [External]
+    PROCEDURE SetIV@1000000009(VAR DotNet_Array@1000000000 : Codeunit 3000);
+    BEGIN
+
+      DotNet_Array.Clone(DotNet_ArrayIV);
+    END;
+
+    [External]
+    PROCEDURE EncryptTextBase64@1000000001(UnEncryptedText@1000000000 : Text;VAR EncryptedTextBase64@1000000003 : Text) : Boolean;
+    VAR
+      Result@1000000002 : Boolean;
+    BEGIN
+
+      IF STRLEN(UnEncryptedText) > 0 THEN
+        Result := TryEncryptTextBase64(UnEncryptedText, EncryptedTextBase64);
+      CLEARLASTERROR;
+      EXIT(Result);
+    END;
+
+    [External]
+    PROCEDURE DecryptTextBase64@1000000002(EncryptedText@1000000000 : Text;VAR UnEncryptedText@1000000003 : Text) : Boolean;
+    VAR
+      Result@1000000002 : Boolean;
+    BEGIN
+
+      IF STRLEN(EncryptedText) > 0 THEN
+        Result := TryDecryptTextBase64(EncryptedText, UnEncryptedText);
+      CLEARLASTERROR;
+      EXIT(Result);
+    END;
+
+    [External]
+    PROCEDURE EncryptTempBlob@1000000006(VAR UnEncryptedTempBlob@1000000000 : Record 99008535;VAR EncryptedTempBlob@1000000003 : Record 99008535) : Boolean;
+    VAR
+      Result@1000000002 : Boolean;
+    BEGIN
+
+      Result := TryEncryptTempBlob(UnEncryptedTempBlob, EncryptedTempBlob);
+      CLEARLASTERROR;
+      EXIT(Result);
+    END;
+
+    [External]
+    PROCEDURE DecryptTempBlob@1000000005(VAR EncryptedTempBlob@1000000000 : Record 99008535;VAR DecryptedTempBlob@1000000003 : Record 99008535) : Boolean;
+    VAR
+      Result@1000000002 : Boolean;
+    BEGIN
+
+      Result := TryDecryptTempBlob(EncryptedTempBlob, DecryptedTempBlob);
+      CLEARLASTERROR;
+      EXIT(Result);
+    END;
+
+    [External]
+    PROCEDURE EncryptStream@1000000003(VAR UnEncryptedStream@1000000002 : InStream;VAR EncryptedStream@1000000000 : OutStream) : Boolean;
+    VAR
+      Result@1000000003 : Boolean;
+    BEGIN
+
+      Result := TryEncryptStream(UnEncryptedStream, EncryptedStream);
+      CLEARLASTERROR;
+      EXIT(Result);
+    END;
+
+    [External]
+    PROCEDURE DecryptStream@1000000004(VAR EncryptedStream@1000000001 : InStream;VAR UnEncryptedStream@1000000000 : OutStream) : Boolean;
+    VAR
+      Result@1000000003 : Boolean;
+    BEGIN
+
+      Result := TryDecryptStream(EncryptedStream, UnEncryptedStream);
+      CLEARLASTERROR;
+      EXIT(Result);
+
+      // Private Interface ======================================================================================
+    END;
+
+    LOCAL PROCEDURE KeyLengthInBytes@1000000017() : Integer;
+    VAR
+      Size@1000000000 : Integer;
+    BEGIN
+
+      IF KeySize = 0 THEN
+        KeySize := 256;
+      EXIT(KeySize/8);
+    END;
+
+    [TryFunction]
+    LOCAL PROCEDURE TryEncryptTextBase64@1000000040(VAR UnEncryptedText@1000000012 : Text;VAR EncryptedTextBase64@1000000014 : Text);
+    VAR
+      OStream@1000000002 : OutStream;
+      TempBlobUnEncrypted@1000000001 : Record 99008535;
+      TempBlobEncrypted@1000000000 : Record 99008535;
+    BEGIN
+
+      // Push unencrypted text into tempblob
+      CLEAR(TempBlobUnEncrypted.Blob);
+      IF UnEncryptedText <> '' THEN BEGIN
+        TempBlobUnEncrypted.Blob.CREATEOUTSTREAM(OStream);
+        OStream.WRITETEXT(UnEncryptedText);
+      END;
+
+      // Encrypt
+      IF TryEncryptTempBlob(TempBlobUnEncrypted, TempBlobEncrypted) THEN
+      BEGIN
+        // Read the encrypted text from the encrypted tempblob
+        EncryptedTextBase64 := TempBlobEncrypted.ToBase64String();
+      END ELSE BEGIN
+        CLEARLASTERROR;
+        ERROR('Encrypt failed');
+      END;
+    END;
+
+    [TryFunction]
+    LOCAL PROCEDURE TryDecryptTextBase64@1000000039(VAR EncryptedTextBase64@1000000001 : Text;VAR DecryptedText@1000000000 : Text);
+    VAR
+      IStream@1000000008 : InStream;
+      TempBlobDecrypted@1000000006 : Record 99008535;
+      TempBlobEncrypted@1000000005 : Record 99008535;
+      DotNet_Encoding@1000000003 : Codeunit 3026;
+      DotNet_MemoryStream@1000000004 : Codeunit 3009;
+      DotNetEncoding@1000000002 : DotNet "'mscorlib'.System.Text.Encoding";
+      DotNetMemoryStream@1000000007 : DotNet "'mscorlib'.System.IO.MemoryStream";
+    BEGIN
+
+      // Anything to do?
+      IF EncryptedTextBase64 = '' THEN
+        EXIT;
+
+      // Push converted base64 encrypted text into blob
+      TempBlobEncrypted.FromBase64String(EncryptedTextBase64);
+
+      // Decrypt
+      IF TryDecryptTempBlob(TempBlobEncrypted, TempBlobDecrypted) AND TempBlobDecrypted.Blob.HASVALUE THEN
+      BEGIN
+        // Create a stream to read from decrypted blob
+        TempBlobDecrypted.Blob.CREATEINSTREAM(IStream);
+
+        // Read the decrypted bytes from the blob
+        DotNet_MemoryStream.InitMemoryStream();
+        DotNet_MemoryStream.CopyFromInStream(IStream);
+        DotNet_MemoryStream.GetMemoryStream(DotNetMemoryStream);
+
+        // Convert to text using UTF8 encoding
+        DotNet_Encoding.UTF8;
+        DotNet_Encoding.GetEncoding(DotNetEncoding);
+        DecryptedText := DotNetEncoding.GetString(DotNetMemoryStream.ToArray());
+
+      END ELSE BEGIN
+        CLEARLASTERROR;
+        ERROR('Decrypt failed');
+      END;
+    END;
+
+    [TryFunction]
+    LOCAL PROCEDURE TryEncryptTempBlob@1000000012(VAR UnEncryptedTempBlob@1000000006 : Record 99008535;VAR EncryptedTempBlob@1000000002 : Record 99008535);
+    VAR
+      IStream@1000000001 : InStream;
+      OStream@1000000000 : OutStream;
+    BEGIN
+
+      // Create a stream to read from unencrypted tempblob
+      UnEncryptedTempBlob.Blob.CREATEINSTREAM(IStream);
+
+      // Create a stream to write to encrypted tempblob
+      EncryptedTempBlob.INIT();
+      EncryptedTempBlob.Blob.CREATEOUTSTREAM(OStream);
+
+      // Encrypt
+      IF NOT TryEncryptStream(IStream, OStream) THEN
+      BEGIN
+        CLEARLASTERROR;
+        ERROR('Encrypt failed');
+      END;
+    END;
+
+    [TryFunction]
+    LOCAL PROCEDURE TryDecryptTempBlob@1000000007(VAR EncryptedTempBlob@1000000001 : Record 99008535;VAR DecryptedTempBlob@1000000000 : Record 99008535);
+    VAR
+      IStream@1000000008 : InStream;
+      OStream@1000000007 : OutStream;
+    BEGIN
+
+      // Create a stream to read from encrypted tempblob
+      EncryptedTempBlob.Blob.CREATEINSTREAM(IStream);
+
+      // Create a stream to write to decrypted tempblob
+      CLEAR(DecryptedTempBlob.Blob);
+      DecryptedTempBlob.Blob.CREATEOUTSTREAM(OStream);
+
+      // Decrypt
+      IF NOT TryDecryptStream(IStream, OStream) THEN
+      BEGIN
+        CLEARLASTERROR;
+        ERROR('Decrypt failed');
+      END;
+    END;
+
+    [TryFunction]
+    LOCAL PROCEDURE TryEncryptStream@1000000035(VAR UnEncryptedStream@1000000001 : InStream;VAR EncryptedStream@1000000000 : OutStream);
+    VAR
+      DotNetSymmetricAlgorithm@1000000021 : DotNet "'mscorlib'.System.Security.Cryptography.SymmetricAlgorithm";
+      DotNetICryptoTransform@1000000020 : DotNet "'mscorlib'.System.Security.Cryptography.ICryptoTransform";
+      DotNetCryptoStream@1000000019 : DotNet "'mscorlib'.System.Security.Cryptography.CryptoStream";
+      DotNetCryptoStreamMode@1000000018 : DotNet "'mscorlib'.System.Security.Cryptography.CryptoStreamMode";
+      DotNetEncoding@1000000017 : DotNet "'mscorlib'.System.Text.Encoding";
+      DotNetStreamReader@1000000016 : DotNet "'mscorlib'.System.IO.StreamReader";
+      DotNetStreamWriter@1000000015 : DotNet "'mscorlib'.System.IO.StreamWriter";
+      DotNetArray@1000000013 : DotNet "'mscorlib'.System.Array";
+      DotNet_SymmetricAlgorithm@1000000012 : Codeunit 50010;
+      DotNet_ICryptoTransform@1000000011 : Codeunit 50013;
+      DotNet_CryptoStream@1000000010 : Codeunit 50014;
+      DotNet_Encoding@1000000009 : Codeunit 3026;
+      DotNet_StreamReader@1000000008 : Codeunit 3027;
+      DotNet_StreamWriter@1000000007 : Codeunit 3025;
+      DotNet_StreamEncrypted@1000000005 : Codeunit 3034;
+      DotNet_StreamDecrypted@1000000004 : Codeunit 3034;
+      DotNet_Array@1000000002 : Codeunit 3000;
+      BytesRead@1000000003 : Integer;
+    BEGIN
+
+      IF TryCreateSymmetricAlgorithm(DotNet_SymmetricAlgorithm) THEN BEGIN
+
+        // encoding used for transforms
+        DotNet_Encoding.UTF8;
+
+        // setup reader for unencrypted stream
+        DotNet_StreamReader.StreamReader(UnEncryptedStream, DotNet_Encoding);
+        DotNet_StreamReader.GetStreamReader(DotNetStreamReader);
+
+        // setup the encryption pipeline
+        DotNet_SymmetricAlgorithm.GetSymmetricAlgorithm(DotNetSymmetricAlgorithm);
+        DotNetICryptoTransform := DotNetSymmetricAlgorithm.CreateEncryptor();
+        DotNet_ICryptoTransform.SetICryptoTransform(DotNetICryptoTransform);
+        DotNet_CryptoStream.CryptoOutStream(EncryptedStream, DotNet_ICryptoTransform);
+        DotNet_CryptoStream.GetCryptoStream(DotNetCryptoStream);
+
+        // setup crypto writer for encrypted stream
+        DotNet_StreamEncrypted.SetStream(DotNetCryptoStream);
+        DotNet_StreamWriter.StreamWriterFromDotNetStream(DotNet_StreamEncrypted, DotNet_Encoding);
+        DotNet_StreamWriter.GetStreamWriter(DotNetStreamWriter);
+
+        // create a byte array buffer for data transfer
+        DotNet_Array.ByteArray(4096);
+        DotNet_Array.GetArray(DotNetArray);
+
+        // encrypt
+        REPEAT
+          BytesRead := DotNetStreamReader.BaseStream.Read(DotNetArray, 0, DotNetArray.Length);
+          IF BytesRead > 0 THEN
+            DotNetStreamWriter.BaseStream.Write(DotNetArray, 0, BytesRead);
+        UNTIL BytesRead < 1;
+        DotNetStreamWriter.Flush();
+
+        // dispose
+        DotNetStreamReader.Dispose();
+        DotNetStreamWriter.Dispose();
+        DotNetCryptoStream.Dispose();
+        DotNetICryptoTransform.Dispose();
+        DotNetSymmetricAlgorithm.Dispose();
+      END;
+    END;
+
+    [TryFunction]
+    LOCAL PROCEDURE TryDecryptStream@1000000036(VAR EncryptedStream@1000000001 : InStream;VAR DecryptedStream@1000000000 : OutStream);
+    VAR
+      DotNetSymmetricAlgorithm@1000000010 : DotNet "'mscorlib'.System.Security.Cryptography.SymmetricAlgorithm";
+      DotNetICryptoTransform@1000000016 : DotNet "'mscorlib'.System.Security.Cryptography.ICryptoTransform";
+      DotNetCryptoStream@1000000008 : DotNet "'mscorlib'.System.Security.Cryptography.CryptoStream";
+      DotNetCryptoStreamMode@1000000007 : DotNet "'mscorlib'.System.Security.Cryptography.CryptoStreamMode";
+      DotNetEncoding@1000000020 : DotNet "'mscorlib'.System.Text.Encoding";
+      DotNetStreamReader@1000000005 : DotNet "'mscorlib'.System.IO.StreamReader";
+      DotNetStreamWriter@1000000004 : DotNet "'mscorlib'.System.IO.StreamWriter";
+      DotNetArray@1000000006 : DotNet "'mscorlib'.System.Array";
+      DotNet_SymmetricAlgorithm@1000000002 : Codeunit 50010;
+      DotNet_ICryptoTransform@1000000009 : Codeunit 50013;
+      DotNet_CryptoStream@1000000011 : Codeunit 50014;
+      DotNet_Encoding@1000000012 : Codeunit 3026;
+      DotNet_StreamReader@1000000013 : Codeunit 3027;
+      DotNet_StreamWriter@1000000014 : Codeunit 3025;
+      DotNet_StreamEncrypted@1000000017 : Codeunit 3034;
+      DotNet_StreamDecrypted@1000000018 : Codeunit 3034;
+      DotNet_Array@1000000015 : Codeunit 3000;
+      BytesRead@1000000003 : Integer;
+    BEGIN
+
+      IF TryCreateSymmetricAlgorithm(DotNet_SymmetricAlgorithm) THEN BEGIN
+
+        // encoding used for transforms
+        DotNet_Encoding.UTF8;
+
+        // setup the decryption pipeline
+        DotNet_SymmetricAlgorithm.GetSymmetricAlgorithm(DotNetSymmetricAlgorithm);
+        DotNetICryptoTransform := DotNetSymmetricAlgorithm.CreateDecryptor();
+        DotNet_ICryptoTransform.SetICryptoTransform(DotNetICryptoTransform);
+        DotNet_CryptoStream.CryptoInStream(EncryptedStream, DotNet_ICryptoTransform);
+        DotNet_CryptoStream.GetCryptoStream(DotNetCryptoStream);
+
+        // setup reader for encrypted stream
+        DotNet_StreamEncrypted.SetStream(DotNetCryptoStream);
+        DotNet_StreamReader.StreamReaderFromDotNetStream(DotNet_StreamEncrypted, DotNet_Encoding);
+        DotNet_StreamReader.GetStreamReader(DotNetStreamReader);
+
+        // setup writer for decrypted stream
+        DotNet_StreamWriter.StreamWriter(DecryptedStream, DotNet_Encoding);
+        DotNet_StreamWriter.GetStreamWriter(DotNetStreamWriter);
+
+        // create a byte array buffer for data transfer
+        DotNet_Array.ByteArray(4096);
+        DotNet_Array.GetArray(DotNetArray);
+
+        // decrypt
+        REPEAT
+          BytesRead := DotNetStreamReader.BaseStream.Read(DotNetArray, 0, DotNetArray.Length);
+          IF BytesRead > 0 THEN
+            DotNetStreamWriter.BaseStream.Write(DotNetArray, 0, BytesRead);
+        UNTIL BytesRead < 1;
+        DotNetStreamWriter.Flush();
+        DotNetStreamWriter.Close();
+
+        // dispose
+        DotNetStreamReader.Dispose();
+        DotNetStreamWriter.Dispose();
+        DotNetCryptoStream.Dispose();
+        DotNetICryptoTransform.Dispose();
+        DotNetSymmetricAlgorithm.Dispose();
+      END;
+    END;
+
+    [TryFunction]
+    LOCAL PROCEDURE TryCreateSymmetricAlgorithm@1000000025(VAR DotNet_SymmetricAlgorithm@1000000005 : Codeunit 50010);
+    VAR
+      DotNet_CipherMode@1000000000 : Codeunit 50015;
+      DotNet_PaddingMode@1000000001 : Codeunit 50016;
+    BEGIN
+
+      IF (DotNet_ArrayIV.Length = 0) OR (DotNet_ArrayIV.Length = 0) THEN
+        ERROR(E_NO_CIPHER);
+
+      DotNet_CipherMode.SetCipherMode(DotNetCipherMode);
+      DotNet_PaddingMode.SetPaddingMode(DotNetPaddingMode);
+
+      DotNet_SymmetricAlgorithm.Create(SymmetricAlgorithm);
+      DotNet_SymmetricAlgorithm.SetMode(DotNet_CipherMode);
+      IF BlockSize > 0 THEN DotNet_SymmetricAlgorithm.SetBlockSize(BlockSize);
+      DotNet_SymmetricAlgorithm.SetPadding(DotNet_PaddingMode);
+      IF KeySize > 0 THEN DotNet_SymmetricAlgorithm.SetKeySize(KeySize);
+      DotNet_SymmetricAlgorithm.SetKey(DotNet_ArrayKey);
+      DotNet_SymmetricAlgorithm.SetIV(DotNet_ArrayIV);
+    END;
+
+    [TryFunction]
+    LOCAL PROCEDURE TrySetCipher@1000000016(VAR TempBlob@1000000000 : Record 99008535);
+    VAR
+      IStream@1000000001 : InStream;
+      DotNet_HashAlgorithm@1000000006 : Codeunit 50012;
+      DotNet_ArrayHashBytes@1000000012 : Codeunit 3000;
+    BEGIN
+
+      // Generate a Key & IV from the cipher text stored in the blob
+      // This method uses a SHA384 hash of the cipher to generate the
+      // bytes for the Key & IV
+
+      TempBlob.Blob.CREATEINSTREAM(IStream);
+
+      DotNet_HashAlgorithm.Create('SHA384');
+      DotNet_HashAlgorithm.ComputeHashFromInStream(IStream, DotNet_ArrayHashBytes);
+
+      DotNet_ArrayKey.ByteArray(KeyLengthInBytes);
+      DotNet_ArrayHashBytes.ConstrainedCopy(0, DotNet_ArrayKey, 0, KeyLengthInBytes);
+
+      DotNet_ArrayIV.ByteArray(16);
+      DotNet_ArrayHashBytes.ConstrainedCopy(KeyLengthInBytes, DotNet_ArrayIV, 0, 16);
+
+      DotNet_HashAlgorithm.Dispose();
+    END;
+
+    BEGIN
+    END.
+  }
+}
+
diff --git a/Test/COD146000.TXT b/Test/COD146000.TXT
index 0c09cd7..00bc223 100644
--- a/Test/COD146000.TXT
+++ b/Test/COD146000.TXT
@@ -132,6 +132,66 @@ OBJECT Codeunit 146000 Test_DotNet_Array
       Assert.AreEqual(Expected,Actual,'All values check failed');
     END;
 
+    [Test]
+    PROCEDURE TestClone@1000000001();
+    VAR
+      Index@1000 : Integer;
+      Actual@1001 : Text;
+      Expected@1002 : Text;
+      DotNet_ArrayClone@1000000000 : Codeunit 3000;
+    BEGIN
+      // [WHEN] Char array of four elements are created
+      DotNet_Array.CharArray(4);
+      DotNet_Array.SetByteValue('1',0);
+      DotNet_Array.SetByteValue('2',1);
+      DotNet_Array.SetByteValue('3',2);
+      DotNet_Array.SetByteValue('4',3);
+      // [WHEN] And array is cloned
+      DotNet_Array.Clone(DotNet_ArrayClone);
+      Actual := '';
+      FOR Index := 0 TO DotNet_ArrayClone.Length - 1 DO
+        Actual += FORMAT(DotNet_ArrayClone.GetValueAsChar(Index));
+      // [THEN] Array must be not null
+      Assert.AreEqual(FALSE,DotNet_ArrayClone.IsNull,'Null check failed');
+      // [THEN] Expected array length is 4
+      Assert.AreEqual(4,DotNet_ArrayClone.Length,'Array length check failed');
+      // [THEN] First element should be 1
+      Assert.AreEqual('1',DotNet_ArrayClone.GetValueAsChar(0),'First element check failed');
+      // [THEN] Concatenated values are '1234'
+      Expected := '1234';
+      Assert.AreEqual(Expected,Actual,'All values check failed');
+    END;
+
+    [Test]
+    PROCEDURE TestConstrainedCopy@1000000003();
+    VAR
+      Index@1000 : Integer;
+      Actual@1001 : Text;
+      Expected@1002 : Text;
+      DotNet_ArrayCopy1@1000000000 : Codeunit 3000;
+      DotNet_ArrayCopy2@1000000001 : Codeunit 3000;
+    BEGIN
+      // [WHEN] Char array of four elements are created
+      DotNet_Array.CharArray(4);
+      DotNet_Array.SetByteValue('1',0);
+      DotNet_Array.SetByteValue('2',1);
+      DotNet_Array.SetByteValue('3',2);
+      DotNet_Array.SetByteValue('4',3);
+      // [WHEN] And array is constrain copied
+      DotNet_ArrayCopy1.CharArray(2);
+      DotNet_ArrayCopy2.CharArray(2);
+      DotNet_Array.ConstrainedCopy(0, DotNet_ArrayCopy1, 0, 2);
+      DotNet_Array.ConstrainedCopy(2, DotNet_ArrayCopy2, 0, 2);
+      Actual := '';
+      FOR Index := 0 TO 1 DO
+        Actual += FORMAT(DotNet_ArrayCopy1.GetValueAsChar(Index));
+      FOR Index := 2 TO 3 DO
+        Actual += FORMAT(DotNet_ArrayCopy2.GetValueAsChar(Index-2));
+      // [THEN] Concatenated values are '1234'
+      Expected := '1234';
+      Assert.AreEqual(Expected,Actual,'All values check failed');
+    END;
+
     BEGIN
     END.
   }
diff --git a/Test/COD146027.TXT b/Test/COD146027.TXT
index b65c212..fbfe570 100644
--- a/Test/COD146027.TXT
+++ b/Test/COD146027.TXT
@@ -22,9 +22,46 @@ OBJECT Codeunit 146027 Test_DotNet_StreamReader
       DotNet_StreamWriter@1002 : Codeunit 3025;
       DotNet_StreamReader@1003 : Codeunit 3027;
       DotNet_Encoding@1004 : Codeunit 3026;
+      DotNet_Stream@1000000003 : Codeunit 3034;
+      FromRawStream@1000000000 : Integer;
+      FromWrappedStream@1000000001 : Integer;
+      IsInitialized@1000000002 : Boolean;
+
+    LOCAL PROCEDURE Initialize@1000000005();
+    BEGIN
+      IF IsInitialized THEN
+        EXIT;
+
+      FromRawStream := 0;
+      FromWrappedStream := 1;
+      IsInitialized := TRUE;
+    END;
 
     [Test]
     PROCEDURE TestReadingUsingReadLine@1();
+    BEGIN
+      Initialize();
+      ReadingUsingReadLine(FromRawStream);
+      ReadingUsingReadLine(FromWrappedStream);
+    END;
+
+    [Test]
+    PROCEDURE TestReadingUsingReadToEnd@2();
+    BEGIN
+      Initialize();
+      ReadingUsingReadToEnd(FromRawStream);
+      ReadingUsingReadToEnd(FromWrappedStream);
+    END;
+
+    [Test]
+    PROCEDURE TestReadingFromStreamsInBalticEncodings@3();
+    BEGIN
+      Initialize();
+      ReadingFromStreamsInBalticEncodings(FromRawStream);
+      ReadingFromStreamsInBalticEncodings(FromWrappedStream);
+    END;
+
+    PROCEDURE ReadingUsingReadLine@1000000004(FromMode@1000000000 : Integer);
     VAR
       Expected@1003 : Text;
       Actual@1000 : Text;
@@ -32,8 +69,8 @@ OBJECT Codeunit 146027 Test_DotNet_StreamReader
       ActualCodepage@1004 : Integer;
     BEGIN
       // [WHEN] One-lined text file with encoding 1252 is created as read line by line
-      CreateSampleStreamFromText('Test',1,1252);
-      ReadLineByLineInGivenCodepage(1252,Count,Actual,ActualCodepage);
+      CreateSampleStreamFromText(FromMode, 'Test',1,1252);
+      ReadLineByLineInGivenCodepage(FromMode, 1252,Count,Actual,ActualCodepage);
       // [THEN] Expected line count is 1 and concatenation of all lines should be 'Test'
       Assert.AreEqual(1252,ActualCodepage,'Codepage check failed');
       Assert.AreEqual(1,Count,'Line count check failed');
@@ -41,64 +78,62 @@ OBJECT Codeunit 146027 Test_DotNet_StreamReader
       Assert.AreEqual(Expected,Actual,'Simple text file read failed');
 
       // [WHEN] Two-lined text file with encoding 1252 is created
-      CreateSampleStreamFromText('Test',2,1252);
-      ReadLineByLineInGivenCodepage(1252,Count,Actual,ActualCodepage);
+      CreateSampleStreamFromText(FromMode, 'Test',2,1252);
+      ReadLineByLineInGivenCodepage(FromMode, 1252,Count,Actual,ActualCodepage);
       // [THEN] Expected line count is 2 and concatenation of all lines should be 'TestTest'
       Assert.AreEqual(2,Count,'Line count check failed');
       Expected := 'TestTest';
       Assert.AreEqual(Expected,Actual,'Simple text file read failed');
     END;
 
-    [Test]
-    PROCEDURE TestReadingUsingReadToEnd@2();
+    PROCEDURE ReadingUsingReadToEnd@1000000003(FromMode@1000000000 : Integer);
     VAR
       Expected@1003 : Text;
       Actual@1000 : Text;
     BEGIN
       // [WHEN] One-lined text file with encoding 1252 is created and whole content is read
-      CreateSampleStreamFromText('Test',0,1252);
-      Actual := ReadToEndInGivenCodepage(1252);
+      CreateSampleStreamFromText(FromMode, 'Test',0,1252);
+      Actual := ReadToEndInGivenCodepage(FromMode, 1252);
       // [THEN] Actual content that was read should be 'Test'
       Expected := 'Test';
       Assert.AreEqual(Expected,Actual,'Simple text file read failed');
     END;
 
-    [Test]
-    PROCEDURE TestReadingFromStreamsInBalticEncodings@3();
+    PROCEDURE ReadingFromStreamsInBalticEncodings@1000000002(FromMode@1000000000 : Integer);
     VAR
       Expected@1003 : Text;
       Actual@1000 : Text;
     BEGIN
       // [GIVEN] A sample text full of Baltic specific characters encoded using Utf8
       CreateSampleStreamFromBase64('xIXEjcSZxJfEr8WhxbPFq8W+xITEjMSYxJbErsWgxbLFqsW9YWJjZA==');
-      Expected := ReadToEndInGivenCodepage(0);
+      Expected := ReadToEndInGivenCodepage(FromMode, 0);
 
       // [WHEN] The same text is read from stream in Windows-1257 encoding:
       CreateSampleStreamFromBase64('4Ojm6+Hw+Pv+wMjGy8HQ2NveYWJjZA==');
-      Actual := ReadToEndInGivenCodepage(1257);
+      Actual := ReadToEndInGivenCodepage(FromMode, 1257);
       // [THEN] Final string from Windows-1257 encoded stream should be the same to string from Utf-8 stream
       Assert.AreEqual(Expected,Actual,'Windows-1257 stream check failed');
 
       // [WHEN] The same text is read from stream in OEM-775 encoding:
       CreateSampleStreamFromBase64('0NHS09TV1tfYtba3uL2+xsfPYWJjZA==');
-      Actual := ReadToEndInGivenCodepage(775);
+      Actual := ReadToEndInGivenCodepage(FromMode, 775);
       // [THEN] Final string from OEM-775 encoded stream should be the same to string from Utf-8 stream
       Assert.AreEqual(Expected,Actual,'OEM-775 stream check failed');
 
       // [WHEN] The same text is read from stream in ISO-8859-4 (Windows-28594) encoding:
       CreateSampleStreamFromBase64('sejq7Oe5+f6+ocjKzMep2d6uYWJjZA==');
-      Actual := ReadToEndInGivenCodepage(28594);
+      Actual := ReadToEndInGivenCodepage(FromMode, 28594);
       // [THEN] Final string from ISO-8859-4 encoded stream should be the same to string from Utf-8 stream
       Assert.AreEqual(Expected,Actual,'ISO-8859-4 stream check failed');
 
       // [WHEN] The same text is read from stream in ISO-8859-13 (Windows-28603) encoding:
       CreateSampleStreamFromBase64('4Ojm6+Hw+Pv+wMjGy8HQ2NveYWJjZA==');
-      Actual := ReadToEndInGivenCodepage(28603);
+      Actual := ReadToEndInGivenCodepage(FromMode, 28603);
       // [THEN] Final string from ISO-8859-13 encoded stream should be the same to string from Utf-8 stream
       Assert.AreEqual(Expected,Actual,'ISO-8859-13 stream check failed');
     END;
 
-    PROCEDURE CreateSampleStreamFromText@4(SampleText@1000 : Text;LineCount@1003 : Integer;Codepage@1001 : Integer);
+    PROCEDURE CreateSampleStreamFromText@4(FromMode@1000000000 : Integer;SampleText@1000 : Text;LineCount@1003 : Integer;Codepage@1001 : Integer);
     VAR
       OutputStream@1002 : OutStream;
       LineNo@1004 : Integer;
@@ -106,7 +141,12 @@ OBJECT Codeunit 146027 Test_DotNet_StreamReader
       CLEAR(TempBlob);
       TempBlob.Blob.CREATEOUTSTREAM(OutputStream);
       DotNet_Encoding.Encoding(Codepage);
-      DotNet_StreamWriter.StreamWriter(OutputStream,DotNet_Encoding);
+      IF FromMode = FromRawStream THEN BEGIN
+        DotNet_StreamWriter.StreamWriter(OutputStream,DotNet_Encoding);
+      END ELSE BEGIN
+        DotNet_Stream.SetStream(OutputStream);
+        DotNet_StreamWriter.StreamWriterFromDotNetStream(DotNet_Stream,DotNet_Encoding);
+      END;
       FOR LineNo := 1 TO LineCount DO
         DotNet_StreamWriter.WriteLine(SampleText);
       IF LineCount = 0 THEN
@@ -122,7 +162,7 @@ OBJECT Codeunit 146027 Test_DotNet_StreamReader
       TempBlob.FromBase64String(Base64);
     END;
 
-    PROCEDURE ReadToEndInGivenCodepage@6(Codepage@1000 : Integer) : Text;
+    PROCEDURE ReadToEndInGivenCodepage@6(FromMode@1000000000 : Integer;Codepage@1000 : Integer) : Text;
     VAR
       InputStream@1001 : InStream;
       ResultText@1002 : Text;
@@ -133,14 +173,19 @@ OBJECT Codeunit 146027 Test_DotNet_StreamReader
       ELSE
         DotNet_Encoding.UTF8;
 
-      DotNet_StreamReader.StreamReader(InputStream,DotNet_Encoding);
+      IF FromMode = FromRawStream THEN BEGIN
+        DotNet_StreamReader.StreamReader(InputStream,DotNet_Encoding);
+      END ELSE BEGIN
+        DotNet_Stream.SetStream(InputStream);
+        DotNet_StreamReader.StreamReaderFromDotNetStream(DotNet_Stream,DotNet_Encoding);
+      END;
       ResultText := DotNet_StreamReader.ReadToEnd;
       DotNet_StreamReader.Close;
       DotNet_StreamReader.Dispose;
       EXIT(ResultText);
     END;
 
-    PROCEDURE ReadLineByLineInGivenCodepage@7(Codepage@1000 : Integer;VAR LineCount@1003 : Integer;VAR ResultText@1004 : Text;VAR StreamCodepage@1005 : Integer);
+    PROCEDURE ReadLineByLineInGivenCodepage@7(FromMode@1000000000 : Integer;Codepage@1000 : Integer;VAR LineCount@1003 : Integer;VAR ResultText@1004 : Text;VAR StreamCodepage@1005 : Integer);
     VAR
       InputStream@1001 : InStream;
       CurrentLine@1002 : Text;
@@ -152,7 +197,12 @@ OBJECT Codeunit 146027 Test_DotNet_StreamReader
       ELSE
         DotNet_Encoding.UTF8;
 
-      DotNet_StreamReader.StreamReader(InputStream,DotNet_Encoding);
+      IF FromMode = FromRawStream THEN BEGIN
+        DotNet_StreamReader.StreamReader(InputStream,DotNet_Encoding);
+      END ELSE BEGIN
+        DotNet_Stream.SetStream(InputStream);
+        DotNet_StreamReader.StreamReaderFromDotNetStream(DotNet_Stream,DotNet_Encoding);
+      END;
       LineCount := 0;
       ResultText := '';
       REPEAT
diff --git a/Test/COD51010.TXT b/Test/COD51010.TXT
new file mode 100644
index 0000000..e5d04a5
--- /dev/null
+++ b/Test/COD51010.TXT
@@ -0,0 +1,236 @@
+OBJECT Codeunit 51010 Test_DotNet_SymmetricAlgorithm
+{
+  OBJECT-PROPERTIES
+  {
+    Date=;
+    Time=;
+    Version List=;
+  }
+  PROPERTIES
+  {
+    Subtype=Test;
+    TestPermissions=Disabled;
+    OnRun=BEGIN
+          END;
+
+  }
+  CODE
+  {
+    VAR
+      Assert@1001 : Codeunit 130000;
+      IsInitialized@1000000002 : Boolean;
+      Algorithm@1000000000 : 'Aes,DES,RC2,Rijndael,TripleDES';
+      Mode@1000000003 : ',CBC,ECB,OFB,CFB,CTS';
+      Padding@1000000001 : ',None,PKCS7,Zeros,ANSIX923,ISO10126';
+
+    [Test]
+    PROCEDURE TestSymmetricAlgorithmCreateAes@1000000006();
+    VAR
+      DotNet_SymmetricAlgorithm@1000000000 : Codeunit 50010;
+      DotNetSymmetricAlgorithm@1000000001 : DotNet "'mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089'.System.Security.Cryptography.SymmetricAlgorithm";
+    BEGIN
+      SymmetricAlgorithmCreateAes();
+    END;
+
+    [Test]
+    PROCEDURE TestSymmetricAlgorithmCreateDES@1000000014();
+    VAR
+      DotNet_SymmetricAlgorithm@1000000000 : Codeunit 50010;
+      DotNetSymmetricAlgorithm@1000000001 : DotNet "'mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089'.System.Security.Cryptography.SymmetricAlgorithm";
+    BEGIN
+      SymmetricAlgorithmCreateDES();
+    END;
+
+    [Test]
+    PROCEDURE TestSymmetricAlgorithmCreateRC2@1000000015();
+    VAR
+      DotNet_SymmetricAlgorithm@1000000000 : Codeunit 50010;
+      DotNetSymmetricAlgorithm@1000000001 : DotNet "'mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089'.System.Security.Cryptography.SymmetricAlgorithm";
+    BEGIN
+      SymmetricAlgorithmCreateRC2();
+    END;
+
+    [Test]
+    PROCEDURE TestSymmetricAlgorithmCreateRijndael@1000000016();
+    VAR
+      DotNet_SymmetricAlgorithm@1000000000 : Codeunit 50010;
+      DotNetSymmetricAlgorithm@1000000001 : DotNet "'mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089'.System.Security.Cryptography.SymmetricAlgorithm";
+    BEGIN
+      SymmetricAlgorithmCreateRijndael();
+    END;
+
+    [Test]
+    PROCEDURE TestSymmetricAlgorithmCreateTripleDES@1000000017();
+    VAR
+      DotNet_SymmetricAlgorithm@1000000000 : Codeunit 50010;
+      DotNetSymmetricAlgorithm@1000000001 : DotNet "'mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089'.System.Security.Cryptography.SymmetricAlgorithm";
+    BEGIN
+      SymmetricAlgorithmCreateTripleDES();
+    END;
+
+    [Test]
+    PROCEDURE TestSetGetMode@1000000008();
+    VAR
+      DotNet_SymmetricAlgorithm@1000000001 : Codeunit 50010;
+      DotNet_CipherMode@1000000002 : Codeunit 50015;
+      DotNet_CipherMode2@1000000003 : Codeunit 50015;
+    BEGIN
+      DotNet_SymmetricAlgorithm.Create('Aes');
+      DotNet_CipherMode.CBC();
+      DotNet_SymmetricAlgorithm.SetMode(DotNet_CipherMode);
+      DotNet_SymmetricAlgorithm.GetMode(DotNet_CipherMode2);
+      Assert.AreEqual(DotNet_CipherMode.Value, DotNet_CipherMode2.Value, 'SymmetricAlgorithm Get/Set Mode failed');
+    END;
+
+    [Test]
+    PROCEDURE TestSetGetPadding@1000000007();
+    VAR
+      DotNet_SymmetricAlgorithm@1000000000 : Codeunit 50010;
+      DotNet_PaddingMode@1000000001 : Codeunit 50016;
+      DotNet_PaddingMode2@1000000002 : Codeunit 50016;
+    BEGIN
+      DotNet_SymmetricAlgorithm.Create('Aes');
+      DotNet_PaddingMode.Zeros();
+      DotNet_SymmetricAlgorithm.SetPadding(DotNet_PaddingMode);
+      DotNet_SymmetricAlgorithm.GetPadding(DotNet_PaddingMode2);
+      Assert.AreEqual(DotNet_PaddingMode.Value, DotNet_PaddingMode.Value, 'SymmetricAlgorithm Get/Set Padding failed');
+    END;
+
+    [Test]
+    PROCEDURE TestSetGetBlockSize@1000000012();
+    VAR
+      DotNet_SymmetricAlgorithm@1000000000 : Codeunit 50010;
+      BlockSize@1000000001 : Integer;
+    BEGIN
+      DotNet_SymmetricAlgorithm.Create('Aes');
+      DotNet_SymmetricAlgorithm.SetBlockSize(128);
+      BlockSize := DotNet_SymmetricAlgorithm.GetBlockSize();
+      Assert.AreEqual(128, BlockSize, 'SymmetricAlgorithm Get/Set Blocksize failed');
+    END;
+
+    [Test]
+    PROCEDURE TestSetGetKeySize@1000000009();
+    VAR
+      DotNet_SymmetricAlgorithm@1000000000 : Codeunit 50010;
+      KeySize@1000000001 : Integer;
+    BEGIN
+      DotNet_SymmetricAlgorithm.Create('Aes');
+      DotNet_SymmetricAlgorithm.SetKeySize(256);
+      KeySize := DotNet_SymmetricAlgorithm.GetKeySize();
+      Assert.AreEqual(256, KeySize, 'SymmetricAlgorithm Get/Set KeySize failed');
+    END;
+
+    [Test]
+    PROCEDURE TestSetGetFeedbackSize@1000000013();
+    VAR
+      DotNet_SymmetricAlgorithm@1000000000 : Codeunit 50010;
+      FeedbackSize@1000000001 : Integer;
+    BEGIN
+      DotNet_SymmetricAlgorithm.Create('Aes');
+      DotNet_SymmetricAlgorithm.SetBlockSize(128);
+      DotNet_SymmetricAlgorithm.SetFeedbackSize(64);
+      FeedbackSize := DotNet_SymmetricAlgorithm.GetFeedbackSize();
+      Assert.AreEqual(64, FeedbackSize, 'SymmetricAlgorithm Get/Set FeedbackSize failed');
+    END;
+
+    [Test]
+    PROCEDURE TestSetGetKey@1000000010();
+    VAR
+      DotNet_SymmetricAlgorithm@1000000000 : Codeunit 50010;
+      DotNet_Array@1000000001 : Codeunit 3000;
+      DotNet_ArrayKey@1000000002 : Codeunit 3000;
+      Index@1000000003 : Integer;
+    BEGIN
+      DotNet_Array.ByteArray(32);
+      FOR Index := 0 TO DotNet_Array.Length-1 DO
+        DotNet_Array.SetByteValue(Index, Index);
+
+      DotNet_SymmetricAlgorithm.Create('Aes');
+      DotNet_SymmetricAlgorithm.SetKeySize(256);
+      DotNet_SymmetricAlgorithm.SetKey(DotNet_Array);
+      DotNet_SymmetricAlgorithm.GetKey(DotNet_ArrayKey);
+      FOR Index := 0 TO DotNet_Array.Length-1 DO
+        Assert.AreEqual(
+          DotNet_Array.GetValueAsInteger(Index),
+          DotNet_ArrayKey.GetValueAsInteger(Index),
+          'SymmetricAlgorithm Get/Set Key failed');
+    END;
+
+    [Test]
+    PROCEDURE TestSetGetIV@1000000011();
+    VAR
+      DotNet_SymmetricAlgorithm@1000000000 : Codeunit 50010;
+      DotNet_Array@1000000003 : Codeunit 3000;
+      DotNet_ArrayIV@1000000002 : Codeunit 3000;
+      Index@1000000001 : Integer;
+    BEGIN
+      DotNet_Array.ByteArray(16);
+      FOR Index := 0 TO DotNet_Array.Length-1 DO
+        DotNet_Array.SetByteValue(Index, Index);
+
+      DotNet_SymmetricAlgorithm.Create('Aes');
+      DotNet_SymmetricAlgorithm.SetBlockSize(128);
+      DotNet_SymmetricAlgorithm.SetIV(DotNet_Array);
+      DotNet_SymmetricAlgorithm.GetIV(DotNet_ArrayIV);
+      FOR Index := 0 TO DotNet_Array.Length-1 DO
+        Assert.AreEqual(
+          DotNet_Array.GetValueAsInteger(Index),
+          DotNet_ArrayIV.GetValueAsInteger(Index),
+          'SymmetricAlgorithm Get/Set IV failed');
+    END;
+
+    PROCEDURE SymmetricAlgorithmCreateAes@1000000000();
+    VAR
+      DotNet_SymmetricAlgorithm@1000000000 : Codeunit 50010;
+      DotNetSymmetricAlgorithm@1000000001 : DotNet "'mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089'.System.Security.Cryptography.SymmetricAlgorithm";
+    BEGIN
+      DotNet_SymmetricAlgorithm.Create('Aes');
+      DotNet_SymmetricAlgorithm.GetSymmetricAlgorithm(DotNetSymmetricAlgorithm);
+      Assert.IsFalse(ISNULL(DotNetSymmetricAlgorithm), 'SymmetricAlgorithm Create AES failed');
+    END;
+
+    PROCEDURE SymmetricAlgorithmCreateDES@1000000003();
+    VAR
+      DotNet_SymmetricAlgorithm@1000000000 : Codeunit 50010;
+      DotNetSymmetricAlgorithm@1000000001 : DotNet "'mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089'.System.Security.Cryptography.SymmetricAlgorithm";
+    BEGIN
+      DotNet_SymmetricAlgorithm.Create('DES');
+      DotNet_SymmetricAlgorithm.GetSymmetricAlgorithm(DotNetSymmetricAlgorithm);
+      Assert.IsFalse(ISNULL(DotNetSymmetricAlgorithm), 'SymmetricAlgorithm Create DES failed');
+    END;
+
+    PROCEDURE SymmetricAlgorithmCreateRC2@1000000001();
+    VAR
+      DotNet_SymmetricAlgorithm@1000000000 : Codeunit 50010;
+      DotNetSymmetricAlgorithm@1000000001 : DotNet "'mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089'.System.Security.Cryptography.SymmetricAlgorithm";
+    BEGIN
+      DotNet_SymmetricAlgorithm.Create('RC2');
+      DotNet_SymmetricAlgorithm.GetSymmetricAlgorithm(DotNetSymmetricAlgorithm);
+      Assert.IsFalse(ISNULL(DotNetSymmetricAlgorithm), 'SymmetricAlgorithm Create RC2 failed');
+    END;
+
+    PROCEDURE SymmetricAlgorithmCreateRijndael@1000000002();
+    VAR
+      DotNet_SymmetricAlgorithm@1000000000 : Codeunit 50010;
+      DotNetSymmetricAlgorithm@1000000001 : DotNet "'mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089'.System.Security.Cryptography.SymmetricAlgorithm";
+    BEGIN
+      DotNet_SymmetricAlgorithm.Create('Rijndael');
+      DotNet_SymmetricAlgorithm.GetSymmetricAlgorithm(DotNetSymmetricAlgorithm);
+      Assert.IsFalse(ISNULL(DotNetSymmetricAlgorithm), 'SymmetricAlgorithm Create Rijndael failed');
+    END;
+
+    PROCEDURE SymmetricAlgorithmCreateTripleDES@1000000004();
+    VAR
+      DotNet_SymmetricAlgorithm@1000000000 : Codeunit 50010;
+      DotNetSymmetricAlgorithm@1000000001 : DotNet "'mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089'.System.Security.Cryptography.SymmetricAlgorithm";
+    BEGIN
+      DotNet_SymmetricAlgorithm.Create('TripleDES');
+      DotNet_SymmetricAlgorithm.GetSymmetricAlgorithm(DotNetSymmetricAlgorithm);
+      Assert.IsFalse(ISNULL(DotNetSymmetricAlgorithm), 'SymmetricAlgorithm Create TripleDES failed');
+    END;
+
+    BEGIN
+    END.
+  }
+}
+
diff --git a/Test/COD51012.TXT b/Test/COD51012.TXT
new file mode 100644
index 0000000..c22223d
--- /dev/null
+++ b/Test/COD51012.TXT
@@ -0,0 +1,131 @@
+OBJECT Codeunit 51012 Test_DotNet_HashAlgorithm
+{
+  OBJECT-PROPERTIES
+  {
+    Date=;
+    Time=;
+    Version List=;
+  }
+  PROPERTIES
+  {
+    Subtype=Test;
+    TestPermissions=Disabled;
+    OnRun=BEGIN
+          END;
+
+  }
+  CODE
+  {
+    VAR
+      Assert@1001 : Codeunit 130000;
+      DotNet_HashAlgorithm@1002 : Codeunit 3025;
+      DotNet_Array@1000000001 : Codeunit 3000;
+
+    [Test]
+    PROCEDURE TestGenerateFromText@1();
+    VAR
+      SampleText@1000000000 : Text;
+      ExpectedText@1000000003 : Text;
+      HashText@1000000001 : Text;
+    BEGIN
+      SampleText := 'Lorem ipsum dolor sit amet, consectetur adipiscing elit';
+
+      // SHA1
+      ExpectedText := '4045ed3c779e3b27760e4da357279508a8452dcb';
+      HashText := GenerateFromText('SHA1', SampleText);
+      Assert.AreEqual(ExpectedText, LOWERCASE(HashText), 'SHA1 Hashes differ, failed');
+      // MD5
+      ExpectedText := 'fc10a08df7fafa3871166646609e1c95';
+      HashText := GenerateFromText('MD5', SampleText);
+      Assert.AreEqual(ExpectedText, LOWERCASE(HashText), 'MD5 Hashes differ, failed');
+      // SHA256
+      ExpectedText := '07fe4d4a25718241af145a93f890eb5469052e251d199d173bd3bd50c3bb4da2';
+      HashText := GenerateFromText('SHA256', SampleText);
+      Assert.AreEqual(ExpectedText, LOWERCASE(HashText), 'SHA256 Hashes differ, failed');
+      // SHA384
+      ExpectedText := '845524c97cf0606df6ce8a2e5a7e35701a9ed12685a366eabef599648dd8ba33c1e176e96efe51320a40a6b65c18c4cf';
+      HashText := GenerateFromText('SHA384', SampleText);
+      Assert.AreEqual(ExpectedText, LOWERCASE(HashText), 'SHA384 Hashes differ, failed');
+      // SHA512
+      ExpectedText := 'd3b3d69ccc163089f91d42ebef0f01dd70ec40deb76a9da5ba63ef5b39601b41a34b04f8236ce9e59a150241716a5e2da9f1bdcc2734d4d7fcd8e69df36022f0';
+      HashText := GenerateFromText('SHA512', SampleText);
+      Assert.AreEqual(ExpectedText, LOWERCASE(HashText), 'SHA512 Hashes differ, failed');
+    END;
+
+    [Test]
+    PROCEDURE TestGenerateFromStream@1000000001();
+    VAR
+      SampleText@1000000002 : Text;
+      ExpectedText@1000000001 : Text;
+      HashText@1000000000 : Text;
+      IStream@1000000003 : InStream;
+      TempBlob@1000000004 : TEMPORARY Record 99008535;
+    BEGIN
+      SampleText := 'Lorem ipsum dolor sit amet, consectetur adipiscing elit';
+
+      CLEAR(TempBlob.Blob);
+      TempBlob.WriteAsText(SampleText, TEXTENCODING::UTF8);
+
+      // SHA1
+      ExpectedText := '4045ed3c779e3b27760e4da357279508a8452dcb';
+      TempBlob.Blob.CREATEINSTREAM(IStream);
+      HashText := GenerateFromStream('SHA1', IStream);
+      Assert.AreEqual(ExpectedText, LOWERCASE(HashText), 'SHA1 Hashes differ, failed');
+      // MD5
+      ExpectedText := 'fc10a08df7fafa3871166646609e1c95';
+      TempBlob.Blob.CREATEINSTREAM(IStream);
+      HashText := GenerateFromStream('MD5', IStream);
+      Assert.AreEqual(ExpectedText, LOWERCASE(HashText), 'MD5 Hashes differ, failed');
+      // SHA256
+      ExpectedText := '07fe4d4a25718241af145a93f890eb5469052e251d199d173bd3bd50c3bb4da2';
+      TempBlob.Blob.CREATEINSTREAM(IStream);
+      HashText := GenerateFromStream('SHA256', IStream);
+      Assert.AreEqual(ExpectedText, LOWERCASE(HashText), 'SHA256 Hashes differ, failed');
+      // SHA384
+      ExpectedText := '845524c97cf0606df6ce8a2e5a7e35701a9ed12685a366eabef599648dd8ba33c1e176e96efe51320a40a6b65c18c4cf';
+      TempBlob.Blob.CREATEINSTREAM(IStream);
+      HashText := GenerateFromStream('SHA384', IStream);
+      Assert.AreEqual(ExpectedText, LOWERCASE(HashText), 'SHA384 Hashes differ, failed');
+      // SHA512
+      ExpectedText := 'd3b3d69ccc163089f91d42ebef0f01dd70ec40deb76a9da5ba63ef5b39601b41a34b04f8236ce9e59a150241716a5e2da9f1bdcc2734d4d7fcd8e69df36022f0';
+      TempBlob.Blob.CREATEINSTREAM(IStream);
+      HashText := GenerateFromStream('SHA512', IStream);
+      Assert.AreEqual(ExpectedText, LOWERCASE(HashText), 'SHA512 Hashes differ, failed');
+    END;
+
+    LOCAL PROCEDURE GenerateFromText@1000000002(HashMode@1000000000 : Text;TextToHash@1000000003 : Text) : Text;
+    VAR
+      DotNet_HashAlgorithm@1000000002 : Codeunit 50012;
+      DotNetBitConverter@1000000004 : DotNet "'mscorlib'.System.BitConverter";
+      DotNetArray@1000000005 : DotNet "'mscorlib'.System.Array";
+      DotNetString@1000000001 : DotNet "'mscorlib'.System.String";
+    BEGIN
+      DotNet_HashAlgorithm.Create(HashMode);
+      DotNet_HashAlgorithm.ComputeHashFromText(TextToHash, DotNet_Array);
+      DotNet_Array.GetArray(DotNetArray);
+      DotNetString := DotNetBitConverter.ToString(DotNetArray);
+      EXIT(DotNetString.Replace('-',''));
+    END;
+
+    LOCAL PROCEDURE GenerateFromStream@1000000003(HashMode@1000000001 : Text;InputStream@1000000000 : InStream) : Text;
+    VAR
+      DotNet_HashAlgorithm@1000000003 : Codeunit 50012;
+      DotNetBitConverter@1000000004 : DotNet "'mscorlib'.System.BitConverter";
+      DotNetArray@1000000002 : DotNet "'mscorlib'.System.Array";
+      DotNetString@1000000005 : DotNet "'mscorlib'.System.String";
+    BEGIN
+      DotNet_HashAlgorithm.Create(HashMode);
+      DotNet_HashAlgorithm.ComputeHashFromInStream(InputStream, DotNet_Array);
+      DotNet_Array.GetArray(DotNetArray);
+      DotNetString := DotNetBitConverter.ToString(DotNetArray);
+      EXIT(DotNetString.Replace('-',''));
+    END;
+
+    BEGIN
+    {
+      // Hashes generated from: https://www.browserling.com/tools/all-hashes
+    }
+    END.
+  }
+}
+
diff --git a/Test/COD51013.TXT b/Test/COD51013.TXT
new file mode 100644
index 0000000..830362a
--- /dev/null
+++ b/Test/COD51013.TXT
@@ -0,0 +1,50 @@
+OBJECT Codeunit 51013 Test_DotNet_ICryptoTransform
+{
+  OBJECT-PROPERTIES
+  {
+    Date=;
+    Time=;
+    Version List=;
+  }
+  PROPERTIES
+  {
+    Subtype=Test;
+    TestPermissions=Disabled;
+    OnRun=BEGIN
+          END;
+
+  }
+  CODE
+  {
+    VAR
+      Assert@1001 : Codeunit 130000;
+
+    [Test]
+    PROCEDURE TestGetSet@1000000000();
+    VAR
+      DotNet_SymmetricAlgorithm@1000000001 : Codeunit 50010;
+      DotNet_ICryptoTransform@1000000000 : Codeunit 50013;
+      DotNetSymmetricAlgorithm@1000000003 : DotNet "'mscorlib'.System.Security.Cryptography.SymmetricAlgorithm";
+      DotNetICryptoTransform@1000000002 : DotNet "'mscorlib'.System.Security.Cryptography.ICryptoTransform";
+      DotNetICryptoTransform2@1000000004 : DotNet "'mscorlib'.System.Security.Cryptography.ICryptoTransform";
+      Algorithm@1000000005 : 'Aes,DES,RC2,Rijndael,TripleDES';
+    BEGIN
+
+      // [WHEN] AES Symmetric Algorithm (with default settings) is created
+      DotNet_SymmetricAlgorithm.Create('Aes');
+      DotNet_SymmetricAlgorithm.GetSymmetricAlgorithm(DotNetSymmetricAlgorithm);
+      // [WHEN] Encryptor transform is created
+      DotNetICryptoTransform := DotNetSymmetricAlgorithm.CreateEncryptor();
+      // [WHEN] DotNet Encryptor transform is set
+      DotNet_ICryptoTransform.SetICryptoTransform(DotNetICryptoTransform);
+      // [WHEN] DotNet Encryptor transform is retrieved
+      DotNet_ICryptoTransform.GetICryptoTransform(DotNetICryptoTransform2);
+      // [THEN] DotNet original and retrived must be equal
+      Assert.IsFalse(ISNULL(DotNetICryptoTransform2), 'ICryptoTransform Get/Set failed');
+    END;
+
+    BEGIN
+    END.
+  }
+}
+
diff --git a/Test/COD51014.TXT b/Test/COD51014.TXT
new file mode 100644
index 0000000..b2a9c6e
--- /dev/null
+++ b/Test/COD51014.TXT
@@ -0,0 +1,84 @@
+OBJECT Codeunit 51014 Test_DotNet_CryptoStream
+{
+  OBJECT-PROPERTIES
+  {
+    Date=;
+    Time=;
+    Version List=;
+  }
+  PROPERTIES
+  {
+    Subtype=Test;
+    TestPermissions=Disabled;
+    OnRun=BEGIN
+          END;
+
+  }
+  CODE
+  {
+    VAR
+      Assert@1001 : Codeunit 130000;
+
+    [Test]
+    PROCEDURE TestCryptoOutStream@1000000000();
+    VAR
+      DotNet_SymmetricAlgorithm@1000000001 : Codeunit 50010;
+      DotNet_ICryptoTransform@1000000000 : Codeunit 50013;
+      DotNet_CryptoStream@1000000005 : Codeunit 50014;
+      TempBlob@1000000007 : TEMPORARY Record 99008535;
+      OStream@1000000008 : OutStream;
+    BEGIN
+      // [WHEN] OutStream is initialized
+      CLEAR(TempBlob.Blob);
+      TempBlob.Blob.CREATEOUTSTREAM(OStream);
+      // [WHEN] AES Symmetric Algorithm (with default settings) is created
+      DotNet_SymmetricAlgorithm.Create('Aes');
+      // [WHEN] Encryptor transform is created
+      DotNet_SymmetricAlgorithm.CreateEncryptor(DotNet_ICryptoTransform);
+      // [WHEN] Encrypting crypto outstream is created
+      DotNet_CryptoStream.CryptoOutStream(OStream, DotNet_ICryptoTransform);
+      // [THEN] Encrypting crypto outstream is not NULL
+      Assert.IsTrue(DotNet_CryptoStream.CanWrite, 'CryptoStream CryptoOutStream failed');
+    END;
+
+    [Test]
+    PROCEDURE TestCryptoInStream@1000000001();
+    VAR
+      DotNet_SymmetricAlgorithm@1000000001 : Codeunit 50010;
+      DotNet_ICryptoTransform@1000000000 : Codeunit 50013;
+      DotNet_CryptoStream@1000000005 : Codeunit 50014;
+      DotNet_Array@1000000010 : Codeunit 3000;
+      TempBlob@1000000004 : TEMPORARY Record 99008535;
+      IStream@1000000006 : InStream;
+      Index@1000000009 : Integer;
+    BEGIN
+      // [WHEN] InStream is initialized
+      CLEAR(TempBlob.Blob);
+      TempBlob.WriteAsText('Lorem ipsum dolor', TEXTENCODING::UTF8);
+      TempBlob.Blob.CREATEINSTREAM(IStream);
+      // [WHEN] AES Symmetric Algorithm (with 256 keysize, 128 blocksize) is created)
+      DotNet_SymmetricAlgorithm.Create('Aes');
+      DotNet_SymmetricAlgorithm.SetKeySize(256);
+      // [WHEN] Any key vector is initialized
+      DotNet_Array.ByteArray(32);
+      FOR Index := 0 TO DotNet_Array.Length-1 DO
+        DotNet_Array.SetByteValue(Index, Index);
+      DotNet_SymmetricAlgorithm.SetKey(DotNet_Array);
+      // [WHEN] Any IV vector is initialized
+      DotNet_Array.ByteArray(16);
+      FOR Index := 0 TO DotNet_Array.Length-1 DO
+        DotNet_Array.SetByteValue(Index, Index);
+      DotNet_SymmetricAlgorithm.SetIV(DotNet_Array);
+      // [WHEN] Decryptor transform is created
+      DotNet_SymmetricAlgorithm.CreateDecryptor(DotNet_ICryptoTransform);
+      // [WHEN] Decrypting crypto instream is created
+      DotNet_CryptoStream.CryptoInStream(IStream, DotNet_ICryptoTransform);
+      // [THEN] Decrypting crypto outstream is not NULL
+      Assert.IsTrue(DotNet_CryptoStream.CanWrite, 'CryptoStream CryptoInStream failed');
+    END;
+
+    BEGIN
+    END.
+  }
+}
+
diff --git a/Test/COD51020.TXT b/Test/COD51020.TXT
new file mode 100644
index 0000000..48451ea
--- /dev/null
+++ b/Test/COD51020.TXT
@@ -0,0 +1,399 @@
+OBJECT Codeunit 51020 Test_Symmetric_Encryption_Mgt
+{
+  OBJECT-PROPERTIES
+  {
+    Date=;
+    Time=;
+    Version List=;
+  }
+  PROPERTIES
+  {
+    Subtype=Test;
+    OnRun=BEGIN
+          END;
+
+  }
+  CODE
+  {
+    VAR
+      Assert@1000000005 : Codeunit 130000;
+      LibraryUtility@1000000001 : Codeunit 131000;
+      LibraryRandom@1000000000 : Codeunit 130440;
+      E_ENCRYPT_FAILED@1000000009 : TextConst 'ENU=Encrypt failed';
+      E_DECRYPT_FAILED@1000000010 : TextConst 'ENU=Decrypt failed';
+      E_ENCRYPTDECRYPT_FAILED@1000000004 : TextConst 'ENU=Encrypt/Decrypt failed';
+      E_EXPECTED_FAILURE@1000000007 : TextConst 'ENU=Expected failure';
+      E_EXPECTED_SUCCESS@1000000008 : TextConst 'ENU=Expected success';
+
+    LOCAL PROCEDURE StringsAreEqual@1000000019(VAR Left@1000000001 : Text;VAR Right@1000000002 : Text) : Boolean;
+    VAR
+      DotNetString@1000000000 : DotNet "'mscorlib'.System.String";
+    BEGIN
+      EXIT(DotNetString.Compare(Left, Right) = 0);
+    END;
+
+    LOCAL PROCEDURE EncryptDecryptText@1000000007(VAR SymmetricEncryption@1000000003 : Codeunit 50020;VAR TextClear@1000000006 : Text;VAR TextEncrypted@1000000007 : Text;VAR TextDecrypted@1000000008 : Text);
+    BEGIN
+      SymmetricEncryption.EncryptTextBase64(TextClear, TextEncrypted);
+      SymmetricEncryption.DecryptTextBase64(TextEncrypted, TextDecrypted);
+    END;
+
+    [Test]
+    PROCEDURE AES_256_CBC_PKCS7_EncryptDecrypt@1000000004();
+    VAR
+      SymmetricEncryption@1000000003 : Codeunit 50020;
+      TextCipher@1000000004 : Text;
+      TextToEncrypt@1000000002 : Text;
+      TextEncrypted@1000000001 : Text;
+      TextDecrypted@1000000000 : Text;
+    BEGIN
+      TextCipher := LibraryUtility.GenerateRandomText(LibraryRandom.RandIntInRange(1,64));
+      TextToEncrypt := LibraryUtility.GenerateRandomText(LibraryRandom.RandIntInRange(1,1024));
+
+      SymmetricEncryption.SetCipher(TextCipher);
+      EncryptDecryptText(SymmetricEncryption, TextToEncrypt, TextEncrypted, TextDecrypted);
+      Assert.IsTrue(StringsAreEqual(TextToEncrypt, TextDecrypted), E_ENCRYPTDECRYPT_FAILED);
+    END;
+
+    [Test]
+    PROCEDURE AES_256_CBC_PKCS7_SetCipherFromBlob_EncryptDecrypt@1000000002();
+    VAR
+      SymmetricEncryption@1000000007 : Codeunit 50020;
+      TextToEncrypt@1000000008 : Text;
+      TextDecrypted@1000000009 : Text;
+      TextEncrypted@1000000014 : Text;
+      TextCipher@1000000011 : Text;
+      TempBlobCipher@1000000000 : Record 99008535;
+    BEGIN
+      TextCipher := LibraryUtility.GenerateRandomText(LibraryRandom.RandIntInRange(1,64));
+      TextToEncrypt := LibraryUtility.GenerateRandomText(100000); // to stress the read buffer
+
+      // Push password into tempblob
+      TempBlobCipher.WriteAsText(TextCipher, TEXTENCODING::UTF8);
+      SymmetricEncryption.SetCipherFromBlob(TempBlobCipher);
+
+      // Encrypt/decrypt
+      EncryptDecryptText(SymmetricEncryption, TextToEncrypt, TextEncrypted, TextDecrypted);
+      Assert.IsTrue(StringsAreEqual(TextToEncrypt, TextDecrypted), E_ENCRYPTDECRYPT_FAILED);
+    END;
+
+    [Test]
+    PROCEDURE AES_256_CBC_PKCS7_SetKeyIV_EncryptDecrypt@1000000018();
+    VAR
+      SymmetricEncryption@1000000007 : Codeunit 50020;
+      TextToEncrypt@1000000008 : Text;
+      TextDecrypted@1000000009 : Text;
+      TextEncrypted@1000000014 : Text;
+      TextEncryptedExpected@1000000001 : Text;
+      TextKey@1000000011 : Text;
+      TextIV@1000000003 : Text;
+      DotNet_ArrayKey@1000000000 : Codeunit 3000;
+      DotNet_ArrayIV@1000000004 : Codeunit 3000;
+      Convert@1000000002 : DotNet "'mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089'.System.Convert";
+    BEGIN
+      TextToEncrypt := 'Lorem ipsum dolor sit amet, consectetur adipiscing elit. Aliquam';
+      TextEncryptedExpected := 'LTQUy/6qPc/hxX87etScoQKXDqrbuuCVsmbIEsB2kqzHVL282etankz2kkxZojacuxu3wv7Q6htZOnXq49SrGGSUBrbJo2hJ2op62GxSmgc=';
+
+      // Base64 representations of Key & IV generated when TrySetPassword is called with a password of 'password'
+      TextKey := 'qLZLq9CsqRpZvbt3YbQh1PK7OCgNOnW6DyHyvrxFWD0=';
+      TextIV  := 'RGxZhmDJTOaAxH0ZwweDpw==';
+
+      // Hex representations - in case you want to test against an online crypto interface
+      // TestKey := 'A8B64BABD0ACA91A59BDBB7761B421D4F2BB38280D3A75BA0F21F2BEBC45583D'
+      // TestIV  := '446C598660C94CE680C47D19C30783A7'
+
+      // Convert TestKey to byte[] & push into tempblob
+      DotNet_ArrayKey.SetArray(Convert.FromBase64String(TextKey));
+
+      // Convert TestIV to byte[] & push into tempblob
+      DotNet_ArrayIV.SetArray(Convert.FromBase64String(TextIV));
+
+      // Encrypt/decrypt
+      SymmetricEncryption.SetKey(DotNet_ArrayKey);
+      SymmetricEncryption.SetIV(DotNet_ArrayIV);
+      EncryptDecryptText(SymmetricEncryption, TextToEncrypt, TextEncrypted, TextDecrypted);
+      Assert.IsTrue(StringsAreEqual(TextToEncrypt, TextDecrypted), E_ENCRYPTDECRYPT_FAILED);
+      Assert.IsTrue(StringsAreEqual(TextEncrypted, TextEncryptedExpected), E_ENCRYPT_FAILED);
+    END;
+
+    [Test]
+    PROCEDURE AES_192_CBC_PKCS7_EncryptDecrypt@1000000027();
+    VAR
+      SymmetricEncryption@1000000003 : Codeunit 50020;
+      TextCipher@1000000004 : Text;
+      TextToEncrypt@1000000002 : Text;
+      TextEncrypted@1000000001 : Text;
+      TextDecrypted@1000000000 : Text;
+    BEGIN
+      TextCipher := LibraryUtility.GenerateRandomText(LibraryRandom.RandIntInRange(1,64));
+      TextToEncrypt := LibraryUtility.GenerateRandomText(LibraryRandom.RandIntInRange(1,1024));
+
+      SymmetricEncryption.SetKeySize(192);
+      SymmetricEncryption.SetCipher(TextCipher);
+      EncryptDecryptText(SymmetricEncryption, TextToEncrypt, TextEncrypted, TextDecrypted);
+      Assert.IsTrue(StringsAreEqual(TextToEncrypt, TextDecrypted), E_ENCRYPTDECRYPT_FAILED);
+    END;
+
+    [Test]
+    PROCEDURE AES_128_CBC_PKCS7_EncryptDecrypt@1000000005();
+    VAR
+      SymmetricEncryption@1000000003 : Codeunit 50020;
+      TextCipher@1000000004 : Text;
+      TextToEncrypt@1000000002 : Text;
+      TextEncrypted@1000000001 : Text;
+      TextDecrypted@1000000000 : Text;
+    BEGIN
+      TextCipher := LibraryUtility.GenerateRandomText(8);
+      TextToEncrypt := LibraryUtility.GenerateRandomText(LibraryRandom.RandIntInRange(1,1024));
+
+      SymmetricEncryption.SetKeySize(128);  // must set key size before cipher
+      SymmetricEncryption.SetCipher(TextCipher);
+      EncryptDecryptText(SymmetricEncryption, TextToEncrypt, TextEncrypted, TextDecrypted);
+      Assert.IsTrue(StringsAreEqual(TextToEncrypt, TextDecrypted), E_ENCRYPTDECRYPT_FAILED);
+    END;
+
+    [Test]
+    PROCEDURE AES_256_CFB_PKCS7_EncryptDecrypt@1000000010();
+    VAR
+      SymmetricEncryption@1000000003 : Codeunit 50020;
+      TextCipher@1000000004 : Text;
+      TextToEncrypt@1000000002 : Text;
+      TextEncrypted@1000000001 : Text;
+      TextDecrypted@1000000000 : Text;
+      DotNet_CipherMode@1000000005 : Codeunit 50015;
+    BEGIN
+      TextCipher := LibraryUtility.GenerateRandomText(LibraryRandom.RandIntInRange(1,64));
+      TextToEncrypt := LibraryUtility.GenerateRandomText(1);
+
+      DotNet_CipherMode.CFB;
+      SymmetricEncryption.SetMode(DotNet_CipherMode);
+      SymmetricEncryption.SetCipher(TextCipher);
+      EncryptDecryptText(SymmetricEncryption, TextToEncrypt, TextEncrypted, TextDecrypted);
+      Assert.IsTrue(StringsAreEqual(TextToEncrypt, TextDecrypted), E_ENCRYPTDECRYPT_FAILED);
+    END;
+
+    [Test]
+    PROCEDURE AES_256_CTS_PKCS7_EncryptDecrypt@1000000014();
+    VAR
+      SymmetricEncryption@1000000003 : Codeunit 50020;
+      TextCipher@1000000004 : Text;
+      TextToEncrypt@1000000002 : Text;
+      TextEncrypted@1000000001 : Text;
+      TextDecrypted@1000000000 : Text;
+    BEGIN
+      // DotNet AES does not support CTS mode
+    END;
+
+    [Test]
+    PROCEDURE AES_256_ECB_PKCS7_EncryptDecrypt@1000000012();
+    VAR
+      SymmetricEncryption@1000000003 : Codeunit 50020;
+      TextCipher@1000000004 : Text;
+      TextToEncrypt@1000000002 : Text;
+      TextEncrypted@1000000001 : Text;
+      TextDecrypted@1000000000 : Text;
+      DotNet_CipherMode@1000000005 : Codeunit 50015;
+    BEGIN
+      TextCipher := LibraryUtility.GenerateRandomText(LibraryRandom.RandIntInRange(1,64));
+      TextToEncrypt := LibraryUtility.GenerateRandomText(LibraryRandom.RandIntInRange(1,1024));
+
+      DotNet_CipherMode.ECB;
+      SymmetricEncryption.SetMode(DotNet_CipherMode);
+      SymmetricEncryption.SetCipher(TextCipher);
+      EncryptDecryptText(SymmetricEncryption, TextToEncrypt, TextEncrypted, TextDecrypted);
+      Assert.IsTrue(StringsAreEqual(TextToEncrypt, TextDecrypted), E_ENCRYPTDECRYPT_FAILED);
+    END;
+
+    [Test]
+    PROCEDURE AES_256_OFB_PKCS7_EncryptDecrypt@1000000015();
+    VAR
+      SymmetricEncryption@1000000003 : Codeunit 50020;
+      TextCipher@1000000004 : Text;
+      TextToEncrypt@1000000002 : Text;
+      TextEncrypted@1000000001 : Text;
+      TextDecrypted@1000000000 : Text;
+    BEGIN
+      // DotNet AES does not support OFB mode
+    END;
+
+    [Test]
+    PROCEDURE AES_256_CBC_ANSIX923_EncryptDecrypt@1000000008();
+    VAR
+      SymmetricEncryption@1000000007 : Codeunit 50020;
+      TextCipher@1000000001 : Text;
+      TextToEncrypt@1000000008 : Text;
+      TextEncrypted@1000000000 : Text;
+      TextDecrypted@1000000009 : Text;
+      DotNet_PaddingMode@1000000002 : Codeunit 50016;
+    BEGIN
+      TextCipher := LibraryUtility.GenerateRandomText(LibraryRandom.RandIntInRange(1,64));
+      TextToEncrypt := LibraryUtility.GenerateRandomText(LibraryRandom.RandIntInRange(1,1024));
+
+      DotNet_PaddingMode.ANSIX923;
+      SymmetricEncryption.SetPadding(DotNet_PaddingMode);
+      SymmetricEncryption.SetCipher(TextCipher);
+      EncryptDecryptText(SymmetricEncryption, TextToEncrypt, TextEncrypted, TextDecrypted);
+      Assert.IsTrue(StringsAreEqual(TextToEncrypt, TextDecrypted), E_ENCRYPTDECRYPT_FAILED);
+    END;
+
+    [Test]
+    PROCEDURE AES_256_CBC_ISO10126_EncryptDecrypt@1000000011();
+    VAR
+      SymmetricEncryption@1000000007 : Codeunit 50020;
+      TextCipher@1000000001 : Text;
+      TextToEncrypt@1000000008 : Text;
+      TextEncrypted@1000000000 : Text;
+      TextDecrypted@1000000009 : Text;
+      DotNet_PaddingMode@1000000002 : Codeunit 50016;
+    BEGIN
+      TextCipher := LibraryUtility.GenerateRandomText(LibraryRandom.RandIntInRange(1,64));
+      TextToEncrypt := LibraryUtility.GenerateRandomText(LibraryRandom.RandIntInRange(1,1024));
+
+      DotNet_PaddingMode.ISO10126;
+      SymmetricEncryption.SetPadding(DotNet_PaddingMode);
+      SymmetricEncryption.SetCipher(TextCipher);
+      EncryptDecryptText(SymmetricEncryption, TextToEncrypt, TextEncrypted, TextDecrypted);
+      Assert.IsTrue(StringsAreEqual(TextToEncrypt, TextDecrypted), E_ENCRYPTDECRYPT_FAILED);
+    END;
+
+    [Test]
+    PROCEDURE AES_256_CBC_Zeros_EncryptDecrypt@1000000013();
+    VAR
+      SymmetricEncryption@1000000007 : Codeunit 50020;
+      TextCipher@1000000001 : Text;
+      TextToEncrypt@1000000008 : Text;
+      TextEncrypted@1000000000 : Text;
+      TextDecrypted@1000000009 : Text;
+      DotNet_PaddingMode@1000000002 : Codeunit 50016;
+    BEGIN
+      TextCipher := LibraryUtility.GenerateRandomText(LibraryRandom.RandIntInRange(1,64));
+      TextToEncrypt := LibraryUtility.GenerateRandomText(LibraryRandom.RandIntInRange(1,1024));
+
+      DotNet_PaddingMode.Zeros;
+      SymmetricEncryption.SetPadding(DotNet_PaddingMode);
+      SymmetricEncryption.SetCipher(TextCipher);
+      EncryptDecryptText(SymmetricEncryption, TextToEncrypt, TextEncrypted, TextDecrypted);
+      Assert.IsTrue(StringsAreEqual(TextToEncrypt, TextDecrypted), E_ENCRYPTDECRYPT_FAILED);
+    END;
+
+    [Test]
+    PROCEDURE AES_256_CBC_PKCS7_EncryptStringFail@1000000016();
+    VAR
+      SymmetricEncryption@1000000003 : Codeunit 50020;
+      TextCipher@1000000004 : Text;
+      TextToEncrypt@1000000002 : Text;
+      TextEncrypted@1000000001 : Text;
+      TextDecrypted@1000000000 : Text;
+    BEGIN
+      TextCipher := '';
+      TextToEncrypt := '';
+      Assert.IsFalse(SymmetricEncryption.EncryptTextBase64(TextToEncrypt, TextEncrypted), E_EXPECTED_FAILURE);
+    END;
+
+    [Test]
+    PROCEDURE AES_256_CBC_PKCS7_DecryptStringFail@1000000017();
+    VAR
+      SymmetricEncryption@1000000003 : Codeunit 50020;
+      TextCipher@1000000004 : Text;
+      TextToEncrypt@1000000001 : Text;
+      TextToDecrypt@1000000002 : Text;
+      TextDecrypted@1000000000 : Text;
+      TextEncrypted@1000000005 : Text;
+    BEGIN
+      TextCipher := LibraryUtility.GenerateRandomText(LibraryRandom.RandIntInRange(1,64));
+      TextToEncrypt := LibraryUtility.GenerateRandomText(LibraryRandom.RandIntInRange(10,100));
+
+      // Encrypt string
+      SymmetricEncryption.SetCipher(TextCipher);
+      Assert.IsTrue(SymmetricEncryption.EncryptTextBase64(TextToEncrypt, TextEncrypted), E_EXPECTED_SUCCESS);
+
+      // Mangle encrypted string
+      TextEncrypted[STRLEN(TextEncrypted)-2] := '_';
+      TextEncrypted[STRLEN(TextEncrypted)-1] := '_';
+      Assert.IsFalse(SymmetricEncryption.DecryptTextBase64(TextEncrypted, TextDecrypted), E_EXPECTED_FAILURE);
+    END;
+
+    [Test]
+    PROCEDURE DES_EncryptDecrypt@1000000006();
+    VAR
+      SymmetricEncryption@1000000003 : Codeunit 50020;
+      TextCipher@1000000004 : Text;
+      TextToEncrypt@1000000002 : Text;
+      TextEncrypted@1000000001 : Text;
+      TextDecrypted@1000000000 : Text;
+    BEGIN
+      TextCipher := LibraryUtility.GenerateRandomText(LibraryRandom.RandIntInRange(1,64));
+      TextToEncrypt := LibraryUtility.GenerateRandomText(LibraryRandom.RandIntInRange(1,1024));
+
+      SymmetricEncryption.SetAlgorithm('DES');
+      SymmetricEncryption.SetCipher(TextCipher);
+      EncryptDecryptText(SymmetricEncryption, TextToEncrypt, TextEncrypted, TextDecrypted);
+      Assert.IsTrue(StringsAreEqual(TextToEncrypt, TextDecrypted), E_ENCRYPTDECRYPT_FAILED);
+    END;
+
+    [Test]
+    PROCEDURE RC2_EncryptDecrypt@1000000001();
+    VAR
+      SymmetricEncryption@1000000003 : Codeunit 50020;
+      TextCipher@1000000004 : Text;
+      TextToEncrypt@1000000002 : Text;
+      TextEncrypted@1000000001 : Text;
+      TextDecrypted@1000000000 : Text;
+    BEGIN
+      TextCipher := LibraryUtility.GenerateRandomText(LibraryRandom.RandIntInRange(1,64));
+      TextToEncrypt := LibraryUtility.GenerateRandomText(LibraryRandom.RandIntInRange(1,1024));
+
+      SymmetricEncryption.SetAlgorithm('RC2');
+      SymmetricEncryption.SetCipher(TextCipher);
+      EncryptDecryptText(SymmetricEncryption, TextToEncrypt, TextEncrypted, TextDecrypted);
+      Assert.IsTrue(StringsAreEqual(TextToEncrypt, TextDecrypted), E_ENCRYPTDECRYPT_FAILED);
+    END;
+
+    [Test]
+    PROCEDURE Rijndael_EncryptDecrypt@1000000003();
+    VAR
+      SymmetricEncryption@1000000003 : Codeunit 50020;
+      TextCipher@1000000004 : Text;
+      TextToEncrypt@1000000002 : Text;
+      TextEncrypted@1000000001 : Text;
+      TextDecrypted@1000000000 : Text;
+    BEGIN
+      TextCipher := LibraryUtility.GenerateRandomText(LibraryRandom.RandIntInRange(1,64));
+      TextToEncrypt := LibraryUtility.GenerateRandomText(LibraryRandom.RandIntInRange(1,1024));
+
+      SymmetricEncryption.SetAlgorithm('Rijndael');
+      SymmetricEncryption.SetCipher(TextCipher);
+      EncryptDecryptText(SymmetricEncryption, TextToEncrypt, TextEncrypted, TextDecrypted);
+      Assert.IsTrue(StringsAreEqual(TextToEncrypt, TextDecrypted), E_ENCRYPTDECRYPT_FAILED);
+    END;
+
+    [Test]
+    PROCEDURE TripleDES_EncryptDecrypt@1000000009();
+    VAR
+      SymmetricEncryption@1000000003 : Codeunit 50020;
+      TextCipher@1000000004 : Text;
+      TextToEncrypt@1000000002 : Text;
+      TextEncrypted@1000000001 : Text;
+      TextDecrypted@1000000000 : Text;
+    BEGIN
+      TextCipher := LibraryUtility.GenerateRandomText(LibraryRandom.RandIntInRange(1,64));
+      TextToEncrypt := LibraryUtility.GenerateRandomText(LibraryRandom.RandIntInRange(1,1024));
+
+      SymmetricEncryption.SetAlgorithm('TripleDES');
+      SymmetricEncryption.SetCipher(TextCipher);
+      EncryptDecryptText(SymmetricEncryption, TextToEncrypt, TextEncrypted, TextDecrypted);
+      Assert.IsTrue(StringsAreEqual(TextToEncrypt, TextDecrypted), E_ENCRYPTDECRYPT_FAILED);
+    END;
+
+    BEGIN
+    {
+
+      A good online tool for verifying encryption results is: http://www.txtwizard.net/crypto
+      (though it only supports 128 bit encryption)
+
+      NOTE: Exercising the EncrypText/DecryptText functions also exercises the *Blob/*Stream functions.
+    }
+    END.
+  }
+}
+