From 1b9e3bb27a40ba89d0077c119436c3d8c79c5ece Mon Sep 17 00:00:00 2001 From: Phil Rios <30962795+quadfin@users.noreply.github.com> Date: Wed, 14 Nov 2018 08:34:44 -0800 Subject: [PATCH 1/5] Add symmetric encryption & tests --- BaseApp/COD50010.TXT | 159 ++++++++++++++ BaseApp/COD50012.TXT | 71 +++++++ BaseApp/COD50013.TXT | 41 ++++ BaseApp/COD50014.TXT | 61 ++++++ BaseApp/COD50020.TXT | 491 +++++++++++++++++++++++++++++++++++++++++++ Test/COD51010.TXT | 218 +++++++++++++++++++ Test/COD51012.TXT | 143 +++++++++++++ Test/COD51013.TXT | 59 ++++++ Test/COD51014.TXT | 107 ++++++++++ Test/COD51020.TXT | 419 ++++++++++++++++++++++++++++++++++++ 10 files changed, 1769 insertions(+) create mode 100644 BaseApp/COD50010.TXT create mode 100644 BaseApp/COD50012.TXT create mode 100644 BaseApp/COD50013.TXT create mode 100644 BaseApp/COD50014.TXT create mode 100644 BaseApp/COD50020.TXT create mode 100644 Test/COD51010.TXT create mode 100644 Test/COD51012.TXT create mode 100644 Test/COD51013.TXT create mode 100644 Test/COD51014.TXT create mode 100644 Test/COD51020.TXT diff --git a/BaseApp/COD50010.TXT b/BaseApp/COD50010.TXT new file mode 100644 index 0000000..90904b9 --- /dev/null +++ b/BaseApp/COD50010.TXT @@ -0,0 +1,159 @@ +OBJECT Codeunit 50010 DotNet_SymmetricAlgorithm +{ + OBJECT-PROPERTIES + { + Date=11/13/18; + Time=[ 4:01:01 PM]; + Modified=Yes; + 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"; + + [External] + PROCEDURE GetBlockSize@1000000000(VAR BlockSize@1000000000 : Integer); + BEGIN + BlockSize := DotNetSymmetricAlgorithm.BlockSize; + END; + + [External] + PROCEDURE SetBlockSize@1000000027(BlockSize@1000000000 : Integer); + BEGIN + DotNetSymmetricAlgorithm.BlockSize := BlockSize; + END; + + [External] + PROCEDURE GetFeedbackSize@1000000007(VAR FeedbackSize@1000000000 : Integer); + BEGIN + FeedbackSize := 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(VAR KeySize@1000000000 : Integer); + BEGIN + KeySize := DotNetSymmetricAlgorithm.KeySize; + END; + + [External] + PROCEDURE SetKeySize@1000000018(KeySize@1000000000 : Integer); + BEGIN + DotNetSymmetricAlgorithm.KeySize := KeySize; + END; + + [External] + PROCEDURE GetMode@1000000004(VAR Mode@1000000000 : ',CBC,ECB,OFB,CFB,CTS'); + VAR + CipherMode@1000000001 : Integer; + BEGIN + CipherMode := DotNetSymmetricAlgorithm.Mode; + Mode := CipherMode; + END; + + [External] + PROCEDURE SetMode@1000000020(Mode@1000000000 : ',CBC,ECB,OFB,CFB,CTS'); + VAR + CipherMode@1000000001 : Integer; + BEGIN + CipherMode := Mode; + DotNetSymmetricAlgorithm.Mode := CipherMode; + END; + + [External] + PROCEDURE GetPadding@1000000005(VAR Padding@1000000000 : ',None,PKCS7,Zeros,ANSIX923,ISO10126'); + VAR + PaddingMode@1000000001 : Integer; + BEGIN + PaddingMode := DotNetSymmetricAlgorithm.Padding; + Padding := PaddingMode; + END; + + [External] + PROCEDURE SetPadding@1000000019(Padding@1000000000 : ',None,PKCS7,Zeros,ANSIX923,ISO10126'); + VAR + PaddingMode@1000000001 : Integer; + BEGIN + PaddingMode := Padding; + DotNetSymmetricAlgorithm.Padding := PaddingMode; + END; + + [External] + PROCEDURE Create@1000000028(Algorithm@1000000000 : 'Aes,DES,RC2,Rijndael,TripleDES'); + BEGIN + Dispose(); + DotNetSymmetricAlgorithm := DotNetSymmetricAlgorithm.Create(FORMAT(Algorithm)); + END; + + [External] + PROCEDURE Dispose@1000000008(); + BEGIN + IF NOT ISNULL(DotNetSymmetricAlgorithm) THEN + DotNetSymmetricAlgorithm.Dispose(); + 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..e642de8 --- /dev/null +++ b/BaseApp/COD50012.TXT @@ -0,0 +1,71 @@ +OBJECT Codeunit 50012 DotNet_HashAlgorithm +{ + OBJECT-PROPERTIES + { + Date=11/13/18; + Time=12:07:12 PM; + Modified=Yes; + Version List=; + } + PROPERTIES + { + OnRun=BEGIN + END; + + } + CODE + { + VAR + DotNetHashAlgorithm@1000000000 : DotNet "'mscorlib'.System.Security.Cryptography.HashAlgorithm"; + + [External] + PROCEDURE Create@1000000005(HashAlgorithm@1000000000 : 'SHA1,MD5,SHA256,SHA384,SHA512'); + BEGIN + IF (HashAlgorithm < 0) OR (HashAlgorithm > 4) THEN + EXIT; + DotNetHashAlgorithm := DotNetHashAlgorithm.Create(FORMAT(HashAlgorithm)); + END; + + [External] + PROCEDURE ComputeHashFromText@1000000000(VAR Text@1000000001 : Text;VAR DotNet_Array@1000 : Codeunit 3000); + VAR + DotNetArray@1000000000 : DotNet "'mscorlib'.System.Array"; + 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); + VAR + DotNetArray@1000000000 : DotNet "'mscorlib'.System.Array"; + 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..8db2b88 --- /dev/null +++ b/BaseApp/COD50013.TXT @@ -0,0 +1,41 @@ +OBJECT Codeunit 50013 DotNet_ICryptoTransform +{ + OBJECT-PROPERTIES + { + Date=11/06/18; + Time=[ 8:19:27 PM]; + Modified=Yes; + 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..8e84842 --- /dev/null +++ b/BaseApp/COD50014.TXT @@ -0,0 +1,61 @@ +OBJECT Codeunit 50014 DotNet_CryptoStream +{ + OBJECT-PROPERTIES + { + Date=11/07/18; + Time=[ 9:09:28 AM]; + Modified=Yes; + Version List=; + } + PROPERTIES + { + OnRun=BEGIN + END; + + } + CODE + { + VAR + DotNetCryptoStream@1000000000 : DotNet "'mscorlib'.System.Security.Cryptography.CryptoStream"; + + [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 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/COD50020.TXT b/BaseApp/COD50020.TXT new file mode 100644 index 0000000..691b9ac --- /dev/null +++ b/BaseApp/COD50020.TXT @@ -0,0 +1,491 @@ +OBJECT Codeunit 50020 Symmetric Encryption Mgt +{ + OBJECT-PROPERTIES + { + Date=11/13/18; + Time=[ 3:23:36 PM]; + Modified=Yes; + Version List=; + } + PROPERTIES + { + OnRun=BEGIN + + // Helper Interface ====================================================================================== + END; + + } + CODE + { + VAR + KeySize@1000000001 : Integer; + BlockSize@1000000000 : Integer; + Algorithm@1000000003 : 'Aes,DES,RC2,Rijndael,TripleDES'; + Mode@1000000002 : ',CBC,ECB,OFB,CFB,CTS'; + Padding@1000000005 : ',None,PKCS7,Zeros,ANSIX923,ISO10126'; + 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 : 'Aes,DES,RC2,Rijndael,TripleDES'); + BEGIN + + Algorithm := 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(CipherMode@1000000000 : ',CBC,ECB,OFB,CFB,CTS'); + BEGIN + + Mode := CipherMode; + END; + + [External] + PROCEDURE SetPadding@1000000000(PaddingMode@1000000000 : ',None,PKCS7,Zeros,ANSIX923,ISO10126'); + BEGIN + + Padding := PaddingMode; + 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); + BEGIN + + IF (DotNet_ArrayIV.Length = 0) OR (DotNet_ArrayIV.Length = 0) THEN + ERROR(E_NO_CIPHER); + + DotNet_SymmetricAlgorithm.Create(Algorithm); + IF Mode > 0 THEN DotNet_SymmetricAlgorithm.SetMode(Mode); + IF BlockSize > 0 THEN DotNet_SymmetricAlgorithm.SetBlockSize(BlockSize); + IF Padding > 0 THEN DotNet_SymmetricAlgorithm.SetPadding(Padding); + 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_HashAlgorithmOption@1000000008 : 'SHA1,MD5,SHA256,SHA384,SHA512'; + 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(DotNet_HashAlgorithmOption::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/COD51010.TXT b/Test/COD51010.TXT new file mode 100644 index 0000000..2b3f66e --- /dev/null +++ b/Test/COD51010.TXT @@ -0,0 +1,218 @@ +OBJECT Codeunit 51010 Test_DotNet_SymmetricAlgorithm +{ + OBJECT-PROPERTIES + { + Date=11/13/18; + Time=[ 4:00:25 PM]; + Modified=Yes; + 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'; + + LOCAL PROCEDURE Initialize@1000000005(); + BEGIN + IF IsInitialized THEN + EXIT; + IsInitialized := TRUE; + END; + + [Test] + PROCEDURE TestSymmetricAlgorithmCreate@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 + Initialize(); + SymmetricAlgorithmCreateAes(); + SymmetricAlgorithmCreateDES(); + SymmetricAlgorithmCreateRC2(); + SymmetricAlgorithmCreateRijndael(); + SymmetricAlgorithmCreateTripleDES(); + END; + + [Test] + PROCEDURE TestSetGetMode@1000000008(); + VAR + DotNet_SymmetricAlgorithm@1000000001 : Codeunit 50010; + CipherMode@1000000000 : ',CBC,ECB,OFB,CFB,CTS'; + BEGIN + Initialize(); + DotNet_SymmetricAlgorithm.Create(Algorithm::Aes); + DotNet_SymmetricAlgorithm.SetMode(Mode::CBC); + DotNet_SymmetricAlgorithm.GetMode(CipherMode); + Assert.AreEqual(Mode::CBC, CipherMode, 'SymmetricAlgorithm Get/Set Mode failed'); + END; + + [Test] + PROCEDURE TestSetGetPadding@1000000007(); + VAR + DotNet_SymmetricAlgorithm@1000000000 : Codeunit 50010; + PaddingMode@1000000001 : ',None,PKCS7,Zeros,ANSIX923,ISO10126'; + BEGIN + Initialize(); + DotNet_SymmetricAlgorithm.Create(Algorithm::Aes); + DotNet_SymmetricAlgorithm.SetMode(Padding::Zeros); + DotNet_SymmetricAlgorithm.GetMode(PaddingMode); + Assert.AreEqual(Padding::Zeros, PaddingMode, 'SymmetricAlgorithm Get/Set Padding failed'); + END; + + [Test] + PROCEDURE TestSetGetBlockSize@1000000012(); + VAR + DotNet_SymmetricAlgorithm@1000000000 : Codeunit 50010; + BlockSize@1000000001 : Integer; + BEGIN + Initialize(); + DotNet_SymmetricAlgorithm.Create(Algorithm::Aes); + DotNet_SymmetricAlgorithm.SetBlockSize(128); + DotNet_SymmetricAlgorithm.GetBlockSize(BlockSize); + Assert.AreEqual(128, BlockSize, 'SymmetricAlgorithm Get/Set Blocksize failed'); + END; + + [Test] + PROCEDURE TestSetGetKeySize@1000000009(); + VAR + DotNet_SymmetricAlgorithm@1000000000 : Codeunit 50010; + KeySize@1000000001 : Integer; + BEGIN + Initialize(); + DotNet_SymmetricAlgorithm.Create(Algorithm::Aes); + DotNet_SymmetricAlgorithm.SetKeySize(256); + DotNet_SymmetricAlgorithm.GetKeySize(KeySize); + Assert.AreEqual(256, KeySize, 'SymmetricAlgorithm Get/Set KeySize failed'); + END; + + [Test] + PROCEDURE TestSetGetFeedbackSize@1000000013(); + VAR + DotNet_SymmetricAlgorithm@1000000000 : Codeunit 50010; + FeedbackSize@1000000001 : Integer; + BEGIN + Initialize(); + DotNet_SymmetricAlgorithm.Create(Algorithm::Aes); + DotNet_SymmetricAlgorithm.SetBlockSize(128); + DotNet_SymmetricAlgorithm.SetFeedbackSize(64); + DotNet_SymmetricAlgorithm.GetFeedbackSize(FeedbackSize); + 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 + Initialize(); + + DotNet_Array.ByteArray(32); + FOR Index := 0 TO DotNet_Array.Length-1 DO + DotNet_Array.SetByteValue(Index, Index); + + DotNet_SymmetricAlgorithm.Create(Algorithm::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 + Initialize(); + + DotNet_Array.ByteArray(16); + FOR Index := 0 TO DotNet_Array.Length-1 DO + DotNet_Array.SetByteValue(Index, Index); + + DotNet_SymmetricAlgorithm.Create(Algorithm::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(Algorithm::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(Algorithm::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(Algorithm::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(Algorithm::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(Algorithm::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..1014563 --- /dev/null +++ b/Test/COD51012.TXT @@ -0,0 +1,143 @@ +OBJECT Codeunit 51012 Test_DotNet_HashAlgorithm +{ + OBJECT-PROPERTIES + { + Date=11/13/18; + Time=[ 4:19:06 PM]; + Modified=Yes; + 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; + HashAlgorithm@1000000000 : 'SHA1,MD5,SHA256,SHA384,SHA512'; + IsInitialized@1000000002 : Boolean; + + LOCAL PROCEDURE Initialize@1000000005(); + BEGIN + IF IsInitialized THEN + EXIT; + IsInitialized := TRUE; + END; + + [Test] + PROCEDURE TestGenerateFromText@1(); + VAR + SampleText@1000000000 : Text; + ExpectedText@1000000003 : Text; + HashText@1000000001 : Text; + BEGIN + Initialize(); + SampleText := 'Lorem ipsum dolor sit amet, consectetur adipiscing elit'; + + // SHA1 + ExpectedText := '4045ed3c779e3b27760e4da357279508a8452dcb'; + HashText := GenerateFromText(HashAlgorithm::SHA1, SampleText); + Assert.AreEqual(ExpectedText, LOWERCASE(HashText), 'SHA1 Hashes differ, failed'); + // MD5 + ExpectedText := 'fc10a08df7fafa3871166646609e1c95'; + HashText := GenerateFromText(HashAlgorithm::MD5, SampleText); + Assert.AreEqual(ExpectedText, LOWERCASE(HashText), 'MD5 Hashes differ, failed'); + // SHA256 + ExpectedText := '07fe4d4a25718241af145a93f890eb5469052e251d199d173bd3bd50c3bb4da2'; + HashText := GenerateFromText(HashAlgorithm::SHA256, SampleText); + Assert.AreEqual(ExpectedText, LOWERCASE(HashText), 'SHA256 Hashes differ, failed'); + // SHA384 + ExpectedText := '845524c97cf0606df6ce8a2e5a7e35701a9ed12685a366eabef599648dd8ba33c1e176e96efe51320a40a6b65c18c4cf'; + HashText := GenerateFromText(HashAlgorithm::SHA384, SampleText); + Assert.AreEqual(ExpectedText, LOWERCASE(HashText), 'SHA384 Hashes differ, failed'); + // SHA512 + ExpectedText := 'd3b3d69ccc163089f91d42ebef0f01dd70ec40deb76a9da5ba63ef5b39601b41a34b04f8236ce9e59a150241716a5e2da9f1bdcc2734d4d7fcd8e69df36022f0'; + HashText := GenerateFromText(HashAlgorithm::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 + Initialize(); + 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(HashAlgorithm::SHA1, IStream); + Assert.AreEqual(ExpectedText, LOWERCASE(HashText), 'SHA1 Hashes differ, failed'); + // MD5 + ExpectedText := 'fc10a08df7fafa3871166646609e1c95'; + TempBlob.Blob.CREATEINSTREAM(IStream); + HashText := GenerateFromStream(HashAlgorithm::MD5, IStream); + Assert.AreEqual(ExpectedText, LOWERCASE(HashText), 'MD5 Hashes differ, failed'); + // SHA256 + ExpectedText := '07fe4d4a25718241af145a93f890eb5469052e251d199d173bd3bd50c3bb4da2'; + TempBlob.Blob.CREATEINSTREAM(IStream); + HashText := GenerateFromStream(HashAlgorithm::SHA256, IStream); + Assert.AreEqual(ExpectedText, LOWERCASE(HashText), 'SHA256 Hashes differ, failed'); + // SHA384 + ExpectedText := '845524c97cf0606df6ce8a2e5a7e35701a9ed12685a366eabef599648dd8ba33c1e176e96efe51320a40a6b65c18c4cf'; + TempBlob.Blob.CREATEINSTREAM(IStream); + HashText := GenerateFromStream(HashAlgorithm::SHA384, IStream); + Assert.AreEqual(ExpectedText, LOWERCASE(HashText), 'SHA384 Hashes differ, failed'); + // SHA512 + ExpectedText := 'd3b3d69ccc163089f91d42ebef0f01dd70ec40deb76a9da5ba63ef5b39601b41a34b04f8236ce9e59a150241716a5e2da9f1bdcc2734d4d7fcd8e69df36022f0'; + TempBlob.Blob.CREATEINSTREAM(IStream); + HashText := GenerateFromStream(HashAlgorithm::SHA512, IStream); + Assert.AreEqual(ExpectedText, LOWERCASE(HashText), 'SHA512 Hashes differ, failed'); + END; + + LOCAL PROCEDURE GenerateFromText@1000000002(HashMode@1000000000 : 'SHA1,MD5,SHA256,SHA384,SHA512';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 : 'SHA1,MD5,SHA256,SHA384,SHA512';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..59b2133 --- /dev/null +++ b/Test/COD51013.TXT @@ -0,0 +1,59 @@ +OBJECT Codeunit 51013 Test_DotNet_ICryptoTransform +{ + OBJECT-PROPERTIES + { + Date=11/13/18; + Time=[ 8:23:46 PM]; + Modified=Yes; + Version List=; + } + PROPERTIES + { + Subtype=Test; + TestPermissions=Disabled; + OnRun=BEGIN + END; + + } + CODE + { + VAR + Assert@1001 : Codeunit 130000; + IsInitialized@1000000002 : Boolean; + + LOCAL PROCEDURE Initialize@1000000005(); + BEGIN + IF IsInitialized THEN + EXIT; + IsInitialized := TRUE; + END; + + [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(Algorithm::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..91d3f66 --- /dev/null +++ b/Test/COD51014.TXT @@ -0,0 +1,107 @@ +OBJECT Codeunit 51014 Test_DotNet_CryptoStream +{ + OBJECT-PROPERTIES + { + Date=11/13/18; + Time=[ 4:42:05 PM]; + Modified=Yes; + Version List=; + } + PROPERTIES + { + Subtype=Test; + TestPermissions=Disabled; + OnRun=BEGIN + END; + + } + CODE + { + VAR + Assert@1001 : Codeunit 130000; + IsInitialized@1000000002 : Boolean; + + LOCAL PROCEDURE Initialize@1000000005(); + BEGIN + IF IsInitialized THEN + EXIT; + IsInitialized := TRUE; + END; + + [Test] + PROCEDURE TestCryptoOutStream@1000000000(); + VAR + DotNet_SymmetricAlgorithm@1000000001 : Codeunit 50010; + DotNet_ICryptoTransform@1000000000 : Codeunit 50013; + DotNet_CryptoStream@1000000005 : Codeunit 50014; + DotNetSymmetricAlgorithm@1000000003 : DotNet "'mscorlib'.System.Security.Cryptography.SymmetricAlgorithm"; + DotNetICryptoTransform@1000000002 : DotNet "'mscorlib'.System.Security.Cryptography.ICryptoTransform"; + DotNetCryptoStream@1000000004 : DotNet "'mscorlib'.System.Security.Cryptography.CryptoStream"; + Algorithm@1000000006 : 'Aes,DES,RC2,Rijndael,TripleDES'; + 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(Algorithm::Aes); + DotNet_SymmetricAlgorithm.GetSymmetricAlgorithm(DotNetSymmetricAlgorithm); + // [WHEN] Encryptor transform is created + DotNetICryptoTransform := DotNetSymmetricAlgorithm.CreateEncryptor(); + DotNet_ICryptoTransform.SetICryptoTransform(DotNetICryptoTransform); + // [WHEN] Encrypting crypto outstream is created + DotNet_CryptoStream.CryptoOutStream(OStream, DotNet_ICryptoTransform); + DotNet_CryptoStream.GetCryptoStream(DotNetCryptoStream); + // [THEN] Encrypting crypto outstream is not NULL + Assert.IsFalse(ISNULL(DotNetCryptoStream), '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; + DotNetSymmetricAlgorithm@1000000003 : DotNet "'mscorlib'.System.Security.Cryptography.SymmetricAlgorithm"; + DotNetICryptoTransform@1000000002 : DotNet "'mscorlib'.System.Security.Cryptography.ICryptoTransform"; + DotNetCryptoStream@1000000007 : DotNet "'mscorlib'.System.Security.Cryptography.CryptoStream"; + Algorithm@1000000008 : 'Aes,DES,RC2,Rijndael,TripleDES'; + 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(Algorithm::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); + DotNet_SymmetricAlgorithm.GetSymmetricAlgorithm(DotNetSymmetricAlgorithm); + // [WHEN] Decryptor transform is created + DotNetICryptoTransform := DotNetSymmetricAlgorithm.CreateDecryptor(); + DotNet_ICryptoTransform.SetICryptoTransform(DotNetICryptoTransform); + // [WHEN] Decrypting crypto instream is created + DotNet_CryptoStream.CryptoInStream(IStream, DotNet_ICryptoTransform); + DotNet_CryptoStream.GetCryptoStream(DotNetCryptoStream); + // [THEN] Decrypting crypto outstream is not NULL + Assert.IsFalse(ISNULL(DotNetCryptoStream), 'CryptoStream CryptoInStream failed'); + END; + + BEGIN + END. + } +} + diff --git a/Test/COD51020.TXT b/Test/COD51020.TXT new file mode 100644 index 0000000..9e27765 --- /dev/null +++ b/Test/COD51020.TXT @@ -0,0 +1,419 @@ +OBJECT Codeunit 51020 Test_Symmetric_Encryption_Mgt +{ + OBJECT-PROPERTIES + { + Date=11/13/18; + Time=[ 3:22:43 PM]; + Modified=Yes; + Version List=; + } + PROPERTIES + { + Subtype=Test; + OnRun=BEGIN + IsInitialized := FALSE; + END; + + } + CODE + { + VAR + Algorithm@1000000011 : 'Aes,DES,RC2,Rijndael,TripleDES'; + Mode@1000000003 : ',CBC,ECB,OFB,CFB,CTS'; + Padding@1000000002 : ',None,PKCS7,Zeros,ANSIX923,ISO10126'; + Assert@1000000005 : Codeunit 130000; + LibraryUtility@1000000001 : Codeunit 131000; + LibraryRandom@1000000000 : Codeunit 130440; + IsInitialized@1000000006 : Boolean; + 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 Initialize@1000000000(); + BEGIN + IF IsInitialized THEN + EXIT; + + IsInitialized := TRUE; + END; + + 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 + Initialize(); + 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 + Initialize(); + 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 + Initialize(); + 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 + Initialize(); + 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 + Initialize(); + 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; + BEGIN + Initialize(); + TextCipher := LibraryUtility.GenerateRandomText(LibraryRandom.RandIntInRange(1,64)); + TextToEncrypt := LibraryUtility.GenerateRandomText(1); + + SymmetricEncryption.SetMode(Mode::CFB); + 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; + BEGIN + Initialize(); + TextCipher := LibraryUtility.GenerateRandomText(LibraryRandom.RandIntInRange(1,64)); + TextToEncrypt := LibraryUtility.GenerateRandomText(LibraryRandom.RandIntInRange(1,1024)); + + SymmetricEncryption.SetMode(Mode::ECB); + 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; + BEGIN + Initialize(); + TextCipher := LibraryUtility.GenerateRandomText(LibraryRandom.RandIntInRange(1,64)); + TextToEncrypt := LibraryUtility.GenerateRandomText(LibraryRandom.RandIntInRange(1,1024)); + + SymmetricEncryption.SetPadding(Padding::ANSIX923); + 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; + BEGIN + Initialize(); + TextCipher := LibraryUtility.GenerateRandomText(LibraryRandom.RandIntInRange(1,64)); + TextToEncrypt := LibraryUtility.GenerateRandomText(LibraryRandom.RandIntInRange(1,1024)); + + SymmetricEncryption.SetPadding(Padding::ISO10126); + 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; + BEGIN + Initialize(); + TextCipher := LibraryUtility.GenerateRandomText(LibraryRandom.RandIntInRange(1,64)); + TextToEncrypt := LibraryUtility.GenerateRandomText(LibraryRandom.RandIntInRange(1,1024)); + + SymmetricEncryption.SetPadding(Padding::Zeros); + 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 + Initialize(); + 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 + Initialize(); + 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 + Initialize(); + TextCipher := LibraryUtility.GenerateRandomText(LibraryRandom.RandIntInRange(1,64)); + TextToEncrypt := LibraryUtility.GenerateRandomText(LibraryRandom.RandIntInRange(1,1024)); + + SymmetricEncryption.SetAlgorithm(Algorithm::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 + Initialize(); + TextCipher := LibraryUtility.GenerateRandomText(LibraryRandom.RandIntInRange(1,64)); + TextToEncrypt := LibraryUtility.GenerateRandomText(LibraryRandom.RandIntInRange(1,1024)); + + SymmetricEncryption.SetAlgorithm(Algorithm::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 + Initialize(); + TextCipher := LibraryUtility.GenerateRandomText(LibraryRandom.RandIntInRange(1,64)); + TextToEncrypt := LibraryUtility.GenerateRandomText(LibraryRandom.RandIntInRange(1,1024)); + + SymmetricEncryption.SetAlgorithm(Algorithm::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 + Initialize(); + TextCipher := LibraryUtility.GenerateRandomText(LibraryRandom.RandIntInRange(1,64)); + TextToEncrypt := LibraryUtility.GenerateRandomText(LibraryRandom.RandIntInRange(1,1024)); + + SymmetricEncryption.SetAlgorithm(Algorithm::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. + } +} + From 3578f3756f79b086e0ba86c2f1c0375344924c69 Mon Sep 17 00:00:00 2001 From: Phil Rios <30962795+quadfin@users.noreply.github.com> Date: Fri, 15 Feb 2019 16:36:21 -0800 Subject: [PATCH 2/5] Update per reviewer comments --- BaseApp/COD3000.TXT | 56 +++++++-- BaseApp/COD3025.TXT | 38 +++++- BaseApp/COD3027.TXT | 48 ++++++-- BaseApp/COD50010.TXT | 53 +++++--- BaseApp/COD50012.TXT | 42 ++++--- BaseApp/COD50013.TXT | 9 +- BaseApp/COD50014.TXT | 15 ++- BaseApp/COD50015.TXT | 87 +++++++++++++ BaseApp/COD50016.TXT | 87 +++++++++++++ BaseApp/COD50020.TXT | 288 ++++++++++++++++++++++++------------------- Test/COD146000.TXT | 60 +++++++++ Test/COD146027.TXT | 92 ++++++++++---- Test/COD51010.TXT | 5 +- Test/COD51012.TXT | 5 +- Test/COD51013.TXT | 5 +- Test/COD51014.TXT | 5 +- Test/COD51020.TXT | 5 +- 17 files changed, 678 insertions(+), 222 deletions(-) create mode 100644 BaseApp/COD50015.TXT create mode 100644 BaseApp/COD50016.TXT diff --git a/BaseApp/COD3000.TXT b/BaseApp/COD3000.TXT index c8080a4..d1aac3c 100644 --- a/BaseApp/COD3000.TXT +++ b/BaseApp/COD3000.TXT @@ -2,8 +2,9 @@ OBJECT Codeunit 3000 DotNet_Array { OBJECT-PROPERTIES { - Date=; - Time=; + Date=20181113D; + Time=104906T; + Modified=true; Version List=; } PROPERTIES @@ -18,99 +19,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..2c1f798 100644 --- a/BaseApp/COD3025.TXT +++ b/BaseApp/COD3025.TXT @@ -2,8 +2,9 @@ OBJECT Codeunit 3025 DotNet_StreamWriter { OBJECT-PROPERTIES { - Date=; - Time=; + Date=20181113D; + Time=102817T; + Modified=true; Version List=; } PROPERTIES @@ -18,19 +19,22 @@ OBJECT Codeunit 3025 DotNet_StreamWriter DotNetStreamWriter@1001 : DotNet "'mscorlib'.System.IO.StreamWriter"; [External] + [LineStart(57)] PROCEDURE Write@6(Text@1000 : Text); BEGIN DotNetStreamWriter.Write(Text); END; [External] + [LineStart(60)] PROCEDURE WriteLine@2(LineText@1000 : Text); BEGIN DotNetStreamWriter.WriteLine(LineText); END; [External] - PROCEDURE StreamWriter@1(VAR OutStream@1000 : OutStream;DotNet_Encoding@1001 : Codeunit 3026); + [LineStart(63)] + PROCEDURE StreamWriter@1(VAR OutStream@1000 : OutStream;DotNet_Encoding@1001 : Codeunit DotNet_Encoding); VAR DotNetEncoding@1002 : DotNet "'mscorlib'.System.Text.Encoding"; BEGIN @@ -39,29 +43,57 @@ OBJECT Codeunit 3025 DotNet_StreamWriter END; [External] + [LineStart(67)] + PROCEDURE StreamWriterFromDotNetStream@1000000001(VAR DotNet_Stream@1000 : Codeunit DotNet_Stream;DotNet_Encoding@1001 : Codeunit DotNet_Encoding); + 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] + [LineStart(72)] PROCEDURE StreamWriterWithDefaultEncoding@7(VAR OutStream@1000 : OutStream); BEGIN DotNetStreamWriter := DotNetStreamWriter.StreamWriter(OutStream); END; [External] + [LineStart(75)] PROCEDURE Flush@3(); BEGIN DotNetStreamWriter.Flush; END; [External] + [LineStart(78)] PROCEDURE Close@4(); BEGIN DotNetStreamWriter.Close; END; [External] + [LineStart(81)] PROCEDURE Dispose@5(); BEGIN DotNetStreamWriter.Dispose; END; + [LineStart(84)] + PROCEDURE GetStreamWriter@1000000000(VAR DotNetStreamWriter2@1000000000 : DotNet "'mscorlib'.System.IO.StreamWriter"); + BEGIN + DotNetStreamWriter2 := DotNetStreamWriter; + END; + + [LineStart(87)] + 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..ed147fa 100644 --- a/BaseApp/COD3027.TXT +++ b/BaseApp/COD3027.TXT @@ -2,8 +2,9 @@ OBJECT Codeunit 3027 DotNet_StreamReader { OBJECT-PROPERTIES { - Date=; - Time=; + Date=20181113D; + Time=102833T; + Modified=true; Version List=; } PROPERTIES @@ -18,7 +19,8 @@ OBJECT Codeunit 3027 DotNet_StreamReader DotNetStreamReader@1000 : DotNet "'mscorlib'.System.IO.StreamReader"; [External] - PROCEDURE StreamReader@1(VAR InputStream@1000 : InStream;DotNet_Encoding@1001 : Codeunit 3026); + [LineStart(92)] + PROCEDURE StreamReader@1(VAR InputStream@1000 : InStream;DotNet_Encoding@1001 : Codeunit DotNet_Encoding); VAR DotNetEncoding@1002 : DotNet "'mscorlib'.System.Text.Encoding"; BEGIN @@ -27,45 +29,77 @@ OBJECT Codeunit 3027 DotNet_StreamReader END; [External] + [LineStart(96)] + PROCEDURE StreamReaderFromDotNetStream@1000000000(VAR DotNet_Stream@1000 : Codeunit DotNet_Stream;DotNet_Encoding@1001 : Codeunit DotNet_Encoding); + 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] + [LineStart(102)] PROCEDURE StreamReaderDetectEncoding@2(VAR InputStream@1000 : InStream;DetectEncodingFromByteOrderMarks@1001 : Boolean); BEGIN DotNetStreamReader := DotNetStreamReader.StreamReader(InputStream,DetectEncodingFromByteOrderMarks); END; [External] + [LineStart(105)] PROCEDURE Close@3(); BEGIN DotNetStreamReader.Close; END; [External] + [LineStart(108)] PROCEDURE Dispose@4(); BEGIN DotNetStreamReader.Dispose; END; [External] + [LineStart(111)] PROCEDURE EndOfStream@6() : Boolean; BEGIN - EXIT(DotNetStreamReader.EndOfStream); + exit(DotNetStreamReader.EndOfStream); END; [External] - PROCEDURE CurrentEncoding@7(VAR DotNet_Encoding@1000 : Codeunit 3026); + [LineStart(114)] + PROCEDURE CurrentEncoding@7(VAR DotNet_Encoding@1000 : Codeunit DotNet_Encoding); BEGIN DotNet_Encoding.SetEncoding(DotNetStreamReader.CurrentEncoding); END; [External] + [LineStart(117)] PROCEDURE ReadLine@8() : Text; BEGIN - EXIT(DotNetStreamReader.ReadLine); + exit(DotNetStreamReader.ReadLine); END; [External] + [LineStart(120)] PROCEDURE ReadToEnd@9() : Text; BEGIN - EXIT(DotNetStreamReader.ReadToEnd); + exit(DotNetStreamReader.ReadToEnd); + END; + + [LineStart(123)] + PROCEDURE GetStreamReader@1000000001(VAR DotNetStreamReader2@1000000000 : DotNet "'mscorlib'.System.IO.StreamReader"); + BEGIN + DotNetStreamReader2 := DotNetStreamReader; + END; + + [LineStart(126)] + PROCEDURE SetStreamReader@1000000002(VAR DotNetStreamReader2@1000000000 : DotNet "'mscorlib'.System.IO.StreamReader"); + BEGIN + DotNetStreamReader := DotNetStreamReader2; END; BEGIN diff --git a/BaseApp/COD50010.TXT b/BaseApp/COD50010.TXT index 90904b9..1bb14ec 100644 --- a/BaseApp/COD50010.TXT +++ b/BaseApp/COD50010.TXT @@ -2,9 +2,9 @@ OBJECT Codeunit 50010 DotNet_SymmetricAlgorithm { OBJECT-PROPERTIES { - Date=11/13/18; - Time=[ 4:01:01 PM]; - Modified=Yes; + Date=20190215D; + Time=110335.543T; + Modified=true; Version List=; } PROPERTIES @@ -17,33 +17,39 @@ OBJECT Codeunit 50010 DotNet_SymmetricAlgorithm { VAR DotNetSymmetricAlgorithm@1000000000 : DotNet "'mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089'.System.Security.Cryptography.SymmetricAlgorithm"; + EALGORITHM@1000000001 : TextConst 'ENU=Invalid Algorithm'; [External] - PROCEDURE GetBlockSize@1000000000(VAR BlockSize@1000000000 : Integer); + [LineStart(131)] + PROCEDURE GetBlockSize@1000000000() : Integer; BEGIN - BlockSize := DotNetSymmetricAlgorithm.BlockSize; + exit(DotNetSymmetricAlgorithm.BlockSize); END; [External] + [LineStart(134)] PROCEDURE SetBlockSize@1000000027(BlockSize@1000000000 : Integer); BEGIN DotNetSymmetricAlgorithm.BlockSize := BlockSize; END; [External] - PROCEDURE GetFeedbackSize@1000000007(VAR FeedbackSize@1000000000 : Integer); + [LineStart(137)] + PROCEDURE GetFeedbackSize@1000000007() : Integer; BEGIN - FeedbackSize := DotNetSymmetricAlgorithm.FeedbackSize; + exit(DotNetSymmetricAlgorithm.FeedbackSize); END; [External] + [LineStart(140)] PROCEDURE SetFeedbackSize@1000000006(FeedbackSize@1000000000 : Integer); BEGIN DotNetSymmetricAlgorithm.FeedbackSize := FeedbackSize; END; [External] - PROCEDURE GetIV@1000000001(VAR DotNet_Array@1000000000 : Codeunit 3000); + [LineStart(143)] + PROCEDURE GetIV@1000000001(VAR DotNet_Array@1000000000 : Codeunit DotNet_Array); VAR DotNetArray@1000000001 : DotNet "'mscorlib'.System.Array"; BEGIN @@ -53,7 +59,8 @@ OBJECT Codeunit 50010 DotNet_SymmetricAlgorithm END; [External] - PROCEDURE SetIV@1000000023(VAR DotNet_Array@1000000000 : Codeunit 3000); + [LineStart(148)] + PROCEDURE SetIV@1000000023(VAR DotNet_Array@1000000000 : Codeunit DotNet_Array); VAR DotNetArray@1000000001 : DotNet "'mscorlib'.System.Array"; BEGIN @@ -62,7 +69,8 @@ OBJECT Codeunit 50010 DotNet_SymmetricAlgorithm END; [External] - PROCEDURE GetKey@1000000002(VAR DotNet_Array@1000000000 : Codeunit 3000); + [LineStart(152)] + PROCEDURE GetKey@1000000002(VAR DotNet_Array@1000000000 : Codeunit DotNet_Array); VAR DotNetArray@1000000001 : DotNet "'mscorlib'.System.Array"; BEGIN @@ -72,7 +80,8 @@ OBJECT Codeunit 50010 DotNet_SymmetricAlgorithm END; [External] - PROCEDURE SetKey@1000000021(VAR DotNet_Array@1000000000 : Codeunit 3000); + [LineStart(157)] + PROCEDURE SetKey@1000000021(VAR DotNet_Array@1000000000 : Codeunit DotNet_Array); VAR DotNetArray@1000000001 : DotNet "'mscorlib'.System.Array"; BEGIN @@ -81,18 +90,21 @@ OBJECT Codeunit 50010 DotNet_SymmetricAlgorithm END; [External] - PROCEDURE GetKeySize@1000000003(VAR KeySize@1000000000 : Integer); + [LineStart(161)] + PROCEDURE GetKeySize@1000000003() : Integer; BEGIN - KeySize := DotNetSymmetricAlgorithm.KeySize; + exit(DotNetSymmetricAlgorithm.KeySize); END; [External] + [LineStart(164)] PROCEDURE SetKeySize@1000000018(KeySize@1000000000 : Integer); BEGIN DotNetSymmetricAlgorithm.KeySize := KeySize; END; [External] + [LineStart(167)] PROCEDURE GetMode@1000000004(VAR Mode@1000000000 : ',CBC,ECB,OFB,CFB,CTS'); VAR CipherMode@1000000001 : Integer; @@ -102,6 +114,7 @@ OBJECT Codeunit 50010 DotNet_SymmetricAlgorithm END; [External] + [LineStart(171)] PROCEDURE SetMode@1000000020(Mode@1000000000 : ',CBC,ECB,OFB,CFB,CTS'); VAR CipherMode@1000000001 : Integer; @@ -111,6 +124,7 @@ OBJECT Codeunit 50010 DotNet_SymmetricAlgorithm END; [External] + [LineStart(175)] PROCEDURE GetPadding@1000000005(VAR Padding@1000000000 : ',None,PKCS7,Zeros,ANSIX923,ISO10126'); VAR PaddingMode@1000000001 : Integer; @@ -120,6 +134,7 @@ OBJECT Codeunit 50010 DotNet_SymmetricAlgorithm END; [External] + [LineStart(179)] PROCEDURE SetPadding@1000000019(Padding@1000000000 : ',None,PKCS7,Zeros,ANSIX923,ISO10126'); VAR PaddingMode@1000000001 : Integer; @@ -129,24 +144,30 @@ OBJECT Codeunit 50010 DotNet_SymmetricAlgorithm END; [External] - PROCEDURE Create@1000000028(Algorithm@1000000000 : 'Aes,DES,RC2,Rijndael,TripleDES'); + [LineStart(183)] + PROCEDURE Create@1000000028(Algorithm@1000000000 : Text); BEGIN + if not (UpperCase(Algorithm) in ['AES','DES','RC2','RIJNDAEL','TRIPLEDES']) then + Error(EALGORITHM); Dispose(); - DotNetSymmetricAlgorithm := DotNetSymmetricAlgorithm.Create(FORMAT(Algorithm)); + DotNetSymmetricAlgorithm := DotNetSymmetricAlgorithm.Create(Algorithm); END; [External] + [LineStart(189)] PROCEDURE Dispose@1000000008(); BEGIN - IF NOT ISNULL(DotNetSymmetricAlgorithm) THEN + if not IsNull(DotNetSymmetricAlgorithm) then DotNetSymmetricAlgorithm.Dispose(); END; + [LineStart(193)] 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; + [LineStart(196)] PROCEDURE SetSymmetricAlgorithm@1000000014(VAR DotNetSymmetricAlgorithm2@1000000000 : DotNet "'mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089'.System.Security.Cryptography.SymmetricAlgorithm"); BEGIN DotNetSymmetricAlgorithm := DotNetSymmetricAlgorithm2; diff --git a/BaseApp/COD50012.TXT b/BaseApp/COD50012.TXT index e642de8..49faacb 100644 --- a/BaseApp/COD50012.TXT +++ b/BaseApp/COD50012.TXT @@ -2,9 +2,9 @@ OBJECT Codeunit 50012 DotNet_HashAlgorithm { OBJECT-PROPERTIES { - Date=11/13/18; - Time=12:07:12 PM; - Modified=Yes; + Date=20190215D; + Time=115932.293T; + Modified=true; Version List=; } PROPERTIES @@ -17,48 +17,62 @@ OBJECT Codeunit 50012 DotNet_HashAlgorithm { VAR DotNetHashAlgorithm@1000000000 : DotNet "'mscorlib'.System.Security.Cryptography.HashAlgorithm"; + EALGORITHM@1000000001 : TextConst 'ENU=Invalid Hash Algorithm'; [External] - PROCEDURE Create@1000000005(HashAlgorithm@1000000000 : 'SHA1,MD5,SHA256,SHA384,SHA512'); + [LineStart(201)] + PROCEDURE Create@1000000005(HashAlgorithm@1000000000 : Text); BEGIN - IF (HashAlgorithm < 0) OR (HashAlgorithm > 4) THEN - EXIT; - DotNetHashAlgorithm := DotNetHashAlgorithm.Create(FORMAT(HashAlgorithm)); + if not (UpperCase(HashAlgorithm) in ['SHA1','MD5','SHA256','SHA384','SHA512']) then + Error(EALGORITHM); + DotNetHashAlgorithm := DotNetHashAlgorithm.Create(HashAlgorithm); END; [External] - PROCEDURE ComputeHashFromText@1000000000(VAR Text@1000000001 : Text;VAR DotNet_Array@1000 : Codeunit 3000); + [LineStart(206)] + PROCEDURE ComputeHash@1000000001(VAR DotNet_ArrayData@1000000001 : Codeunit DotNet_Array;VAR DotNet_ArrayHash@1000 : Codeunit DotNet_Array); VAR DotNetArray@1000000000 : DotNet "'mscorlib'.System.Array"; + BEGIN + DotNet_ArrayData.GetArray(DotNetArray); + DotNet_ArrayHash.SetArray(DotNetHashAlgorithm.ComputeHash(DotNetArray)); + END; + + [External] + [LineStart(210)] + PROCEDURE ComputeHashFromText@1000000000(VAR Text@1000000001 : Text;VAR DotNet_Array@1000 : Codeunit DotNet_Array); + VAR DotNetEncoding@1000000002 : DotNet "'mscorlib'.System.Text.Encoding"; - DotNet_Encoding@1000000003 : Codeunit 3026; + DotNet_Encoding@1000000003 : Codeunit DotNet_Encoding; BEGIN - IF Text = '' THEN - EXIT; + 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); - VAR - DotNetArray@1000000000 : DotNet "'mscorlib'.System.Array"; + [LineStart(217)] + PROCEDURE ComputeHashFromInStream@5(VAR IStream@1000000001 : InStream;VAR DotNet_Array@1000 : Codeunit DotNet_Array); BEGIN DotNet_Array.SetArray(DotNetHashAlgorithm.ComputeHash(IStream)); END; [External] + [LineStart(220)] PROCEDURE Dispose@1000000006(); BEGIN DotNetHashAlgorithm.Dispose(); END; + [LineStart(223)] PROCEDURE GetHashAlgorithm@2(VAR DotNetHashAlgorithm2@1000000001 : DotNet "'mscorlib'.System.Security.Cryptography.HashAlgorithm"); BEGIN DotNetHashAlgorithm2 := DotNetHashAlgorithm; END; + [LineStart(226)] PROCEDURE SetHashAlgorithm@3(VAR DotNetHashAlgorithm2@1000000000 : DotNet "'mscorlib'.System.Security.Cryptography.HashAlgorithm"); BEGIN DotNetHashAlgorithm := DotNetHashAlgorithm2; diff --git a/BaseApp/COD50013.TXT b/BaseApp/COD50013.TXT index 8db2b88..3b29d49 100644 --- a/BaseApp/COD50013.TXT +++ b/BaseApp/COD50013.TXT @@ -2,9 +2,9 @@ OBJECT Codeunit 50013 DotNet_ICryptoTransform { OBJECT-PROPERTIES { - Date=11/06/18; - Time=[ 8:19:27 PM]; - Modified=Yes; + Date=20181106D; + Time=201927T; + Modified=true; Version List=; } PROPERTIES @@ -19,16 +19,19 @@ OBJECT Codeunit 50013 DotNet_ICryptoTransform DotNetICryptoTransform@1000000000 : DotNet "'mscorlib'.System.Security.Cryptography.ICryptoTransform"; [External] + [LineStart(231)] PROCEDURE Dispose@1000000006(); BEGIN DotNetICryptoTransform.Dispose() END; + [LineStart(234)] PROCEDURE GetICryptoTransform@2(VAR DotNetICryptoTransform2@1000000001 : DotNet "'mscorlib'.System.Security.Cryptography.ICryptoTransform"); BEGIN DotNetICryptoTransform2 := DotNetICryptoTransform END; + [LineStart(237)] PROCEDURE SetICryptoTransform@3(VAR DotNetICryptoTransform2@1000000000 : DotNet "'mscorlib'.System.Security.Cryptography.ICryptoTransform"); BEGIN DotNetICryptoTransform := DotNetICryptoTransform2 diff --git a/BaseApp/COD50014.TXT b/BaseApp/COD50014.TXT index 8e84842..856c144 100644 --- a/BaseApp/COD50014.TXT +++ b/BaseApp/COD50014.TXT @@ -2,9 +2,9 @@ OBJECT Codeunit 50014 DotNet_CryptoStream { OBJECT-PROPERTIES { - Date=11/07/18; - Time=[ 9:09:28 AM]; - Modified=Yes; + Date=20181107D; + Time=090928T; + Modified=true; Version List=; } PROPERTIES @@ -19,7 +19,8 @@ OBJECT Codeunit 50014 DotNet_CryptoStream DotNetCryptoStream@1000000000 : DotNet "'mscorlib'.System.Security.Cryptography.CryptoStream"; [External] - PROCEDURE CryptoInStream@1000000005(IStream@1000000000 : InStream;VAR DotNet_ICryptoTransform@1000000001 : Codeunit 50013); + [LineStart(242)] + PROCEDURE CryptoInStream@1000000005(IStream@1000000000 : InStream;VAR DotNet_ICryptoTransform@1000000001 : Codeunit DotNet_ICryptoTransform); VAR DotNetICryptoTransform@1000000004 : DotNet "'mscorlib'.System.Security.Cryptography.ICryptoTransform"; DotNetCryptoStreamMode@1000000003 : DotNet "'mscorlib'.System.Security.Cryptography.CryptoStreamMode"; @@ -29,7 +30,8 @@ OBJECT Codeunit 50014 DotNet_CryptoStream END; [External] - PROCEDURE CryptoOutStream@1000000000(OStream@1000000000 : OutStream;VAR DotNet_ICryptoTransform@1000000001 : Codeunit 50013); + [LineStart(246)] + PROCEDURE CryptoOutStream@1000000000(OStream@1000000000 : OutStream;VAR DotNet_ICryptoTransform@1000000001 : Codeunit DotNet_ICryptoTransform); VAR DotNetICryptoTransform@1000000004 : DotNet "'mscorlib'.System.Security.Cryptography.ICryptoTransform"; DotNetCryptoStreamMode@1000000003 : DotNet "'mscorlib'.System.Security.Cryptography.CryptoStreamMode"; @@ -39,16 +41,19 @@ OBJECT Codeunit 50014 DotNet_CryptoStream END; [External] + [LineStart(250)] PROCEDURE Dispose@1000000006(); BEGIN DotNetCryptoStream.Dispose(); END; + [LineStart(253)] PROCEDURE GetCryptoStream@2(VAR DotNetCryptoStream2@1000000000 : DotNet "'mscorlib'.System.Security.Cryptography.CryptoStream"); BEGIN DotNetCryptoStream2 := DotNetCryptoStream; END; + [LineStart(256)] PROCEDURE SetCryptoStream@3(VAR DotNetCryptoStream2@1000000000 : DotNet "'mscorlib'.System.Security.Cryptography.CryptoStream"); BEGIN DotNetCryptoStream := DotNetCryptoStream2; diff --git a/BaseApp/COD50015.TXT b/BaseApp/COD50015.TXT new file mode 100644 index 0000000..8feb756 --- /dev/null +++ b/BaseApp/COD50015.TXT @@ -0,0 +1,87 @@ +OBJECT Codeunit 50015 DotNet_CipherMode +{ + OBJECT-PROPERTIES + { + Date=20190215D; + Time=153450.770T; + Modified=true; + Version List=; + } + PROPERTIES + { + OnRun=BEGIN + END; + + } + CODE + { + VAR + DotNetCipherMode@1000000000 : DotNet "'mscorlib'.System.Security.Cryptography.CipherMode"; + + [External] + [LineStart(261)] + PROCEDURE CBC@1000000000() : Integer; + VAR + Mode@1000000000 : Integer; + BEGIN + Mode := DotNetCipherMode.CBC; + exit(Mode); + END; + + [External] + [LineStart(265)] + PROCEDURE ECB@1000000001() : Integer; + VAR + Mode@1000000000 : Integer; + BEGIN + Mode := DotNetCipherMode.ECB; + exit(Mode); + END; + + [External] + [LineStart(269)] + PROCEDURE OFB@1000000002() : Integer; + VAR + Mode@1000000000 : Integer; + BEGIN + Mode := DotNetCipherMode.OFB; + exit(Mode); + END; + + [External] + [LineStart(273)] + PROCEDURE CFB@1000000003() : Integer; + VAR + Mode@1000000000 : Integer; + BEGIN + Mode := DotNetCipherMode.CFB; + exit(Mode); + END; + + [External] + [LineStart(277)] + PROCEDURE CTS@1000000004() : Integer; + VAR + Mode@1000000000 : Integer; + BEGIN + Mode := DotNetCipherMode.CTS; + exit(Mode); + END; + + [LineStart(281)] + PROCEDURE GetCipherMode@1000000006(VAR DotNetCipherMode2@1000000000 : DotNet "'mscorlib'.System.Security.Cryptography.CipherMode"); + BEGIN + DotNetCipherMode2 := DotNetCipherMode; + END; + + [LineStart(284)] + 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..bcc7988 --- /dev/null +++ b/BaseApp/COD50016.TXT @@ -0,0 +1,87 @@ +OBJECT Codeunit 50016 DotNet_PaddingMode +{ + OBJECT-PROPERTIES + { + Date=20190215D; + Time=154300.203T; + Modified=true; + Version List=; + } + PROPERTIES + { + OnRun=BEGIN + END; + + } + CODE + { + VAR + DotNetPaddingMode@1000000000 : DotNet "'mscorlib'.System.Security.Cryptography.PaddingMode"; + + [External] + [LineStart(289)] + PROCEDURE None@1000000000() : Integer; + VAR + Mode@1000000000 : Integer; + BEGIN + Mode := DotNetPaddingMode.None; + exit(Mode); + END; + + [External] + [LineStart(293)] + PROCEDURE PKCS7@1000000001() : Integer; + VAR + Mode@1000000000 : Integer; + BEGIN + Mode := DotNetPaddingMode.PKCS7; + exit(Mode); + END; + + [External] + [LineStart(297)] + PROCEDURE Zeros@1000000002() : Integer; + VAR + Mode@1000000000 : Integer; + BEGIN + Mode := DotNetPaddingMode.Zeros; + exit(Mode); + END; + + [External] + [LineStart(301)] + PROCEDURE ANSIX923@1000000003() : Integer; + VAR + Mode@1000000000 : Integer; + BEGIN + Mode := DotNetPaddingMode.ANSIX923; + exit(Mode); + END; + + [External] + [LineStart(305)] + PROCEDURE ISO10126@1000000004() : Integer; + VAR + Mode@1000000000 : Integer; + BEGIN + Mode := DotNetPaddingMode.ISO10126; + exit(Mode); + END; + + [LineStart(309)] + PROCEDURE GetPaddingMode@1000000005(VAR DotNetPaddingMode2@1000000000 : DotNet "'mscorlib'.System.Security.Cryptography.PaddingMode"); + BEGIN + DotNetPaddingMode2 := DotNetPaddingMode; + END; + + [LineStart(312)] + PROCEDURE SetPaddingMode@1000000006(VAR DotNetPaddingMode2@1000000000 : DotNet "'mscorlib'.System.Security.Cryptography.PaddingMode"); + BEGIN + DotNetPaddingMode := DotNetPaddingMode2; + END; + + BEGIN + END. + } +} + diff --git a/BaseApp/COD50020.TXT b/BaseApp/COD50020.TXT index 691b9ac..6ec5d3f 100644 --- a/BaseApp/COD50020.TXT +++ b/BaseApp/COD50020.TXT @@ -2,9 +2,9 @@ OBJECT Codeunit 50020 Symmetric Encryption Mgt { OBJECT-PROPERTIES { - Date=11/13/18; - Time=[ 3:23:36 PM]; - Modified=Yes; + Date=20190215D; + Time=161812.983T; + Modified=true; Version List=; } PROPERTIES @@ -20,64 +20,71 @@ OBJECT Codeunit 50020 Symmetric Encryption Mgt VAR KeySize@1000000001 : Integer; BlockSize@1000000000 : Integer; - Algorithm@1000000003 : 'Aes,DES,RC2,Rijndael,TripleDES'; + SymmetricAlgorithm@1000000003 : Text; Mode@1000000002 : ',CBC,ECB,OFB,CFB,CTS'; Padding@1000000005 : ',None,PKCS7,Zeros,ANSIX923,ISO10126'; - DotNet_ArrayKey@1000000008 : Codeunit 3000; - DotNet_ArrayIV@1000000007 : Codeunit 3000; + DotNet_ArrayKey@1000000008 : Codeunit DotNet_Array; + DotNet_ArrayIV@1000000007 : Codeunit DotNet_Array; E_NO_CIPHER@1000000004 : TextConst 'ENU=SymmetricAlgorithm - cipher not defined'; + E_INVALID_CIPHERMODE@1000000006 : TextConst 'ENU=Invalid Cipher mode'; + E_INVALID_PADDINGMODE@1000000009 : TextConst 'ENU=Invalid Padding mode'; [External] + [LineStart(319)] PROCEDURE SetCipher@1000000015(VAR CipherText@1000000000 : Text); VAR - TempBlob@1000000001 : Record 99008535; + TempBlob@1000000001 : Record TempBlob; BEGIN // NOTE: Passing a cipher as plain text is not secure. // For a more secure interface use the SetCipherFromBlob interface - IF CipherText = '' THEN - EXIT; + if CipherText = '' then + exit; TempBlob.WriteAsText(CipherText, TEXTENCODING::UTF8); - IF TrySetCipher(TempBlob) THEN ; + if TrySetCipher(TempBlob) then ; END; [External] - PROCEDURE SetCipherFromBlob@1000000014(VAR TempBlob@1000000000 : Record 99008535); + [LineStart(330)] + PROCEDURE SetCipherFromBlob@1000000014(VAR TempBlob@1000000000 : Record TempBlob); BEGIN - IF TrySetCipher(TempBlob) THEN ; + if TrySetCipher(TempBlob) then ; END; [External] + [LineStart(334)] PROCEDURE Base64ToPlainText@1000000053(Base64Text@1000000000 : Text) : Text; VAR - DotNet_Encoding@1000000001 : Codeunit 3026; - DotNet_Convert@1000000002 : Codeunit 3008; + DotNet_Encoding@1000000001 : Codeunit DotNet_Encoding; + DotNet_Convert@1000000002 : Codeunit DotNet_Convert; DotNetConvert@1000000004 : DotNet "'mscorlib'.System.Convert"; DotNetEncoding@1000000003 : DotNet "'mscorlib'.System.Text.Encoding"; BEGIN - IF Base64Text = '' THEN - EXIT(''); + if Base64Text = '' then + exit(''); DotNet_Encoding.UTF8; DotNet_Encoding.GetEncoding(DotNetEncoding); DotNet_Convert.GetConvert(DotNetConvert); - EXIT(DotNetEncoding.GetString(DotNetConvert.FromBase64String(Base64Text))); + exit(DotNetEncoding.GetString(DotNetConvert.FromBase64String(Base64Text))); // Public Interface ====================================================================================== END; [External] - PROCEDURE SetAlgorithm@1000000023(Algorithm@1000000000 : 'Aes,DES,RC2,Rijndael,TripleDES'); + [LineStart(346)] + PROCEDURE SetAlgorithm@1000000023(Algorithm@1000000000 : Text); BEGIN - Algorithm := Algorithm; + SymmetricAlgorithm := Algorithm; END; [External] + [LineStart(350)] PROCEDURE SetKeySize@1000000021(Size@1000000000 : Integer); BEGIN @@ -85,6 +92,7 @@ OBJECT Codeunit 50020 Symmetric Encryption Mgt END; [External] + [LineStart(354)] PROCEDURE SetBlockSize@1000000022(Size@1000000000 : Integer); BEGIN @@ -92,163 +100,184 @@ OBJECT Codeunit 50020 Symmetric Encryption Mgt END; [External] - PROCEDURE SetMode@1000000024(CipherMode@1000000000 : ',CBC,ECB,OFB,CFB,CTS'); + [LineStart(358)] + PROCEDURE SetMode@1000000024(CipherMode@1000000000 : Integer); + VAR + DotNet_CipherMode@1000000001 : Codeunit DotNet_CipherMode; BEGIN + if (CipherMode < DotNet_CipherMode.CBC) or (CipherMode > DotNet_CipherMode.CTS) then + Error(E_INVALID_CIPHERMODE); Mode := CipherMode; END; [External] - PROCEDURE SetPadding@1000000000(PaddingMode@1000000000 : ',None,PKCS7,Zeros,ANSIX923,ISO10126'); + [LineStart(364)] + PROCEDURE SetPadding@1000000000(PaddingMode@1000000000 : Integer); + VAR + DotNet_PaddingMode@1000000001 : Codeunit DotNet_PaddingMode; BEGIN + if (PaddingMode < DotNet_PaddingMode.None) or (PaddingMode > DotNet_PaddingMode.ISO10126) then + Error(E_INVALID_PADDINGMODE); Padding := PaddingMode; END; [External] - PROCEDURE SetKey@1000000008(VAR DotNet_Array@1000000000 : Codeunit 3000); + [LineStart(370)] + PROCEDURE SetKey@1000000008(VAR DotNet_Array@1000000000 : Codeunit DotNet_Array); BEGIN DotNet_Array.Clone(DotNet_ArrayKey); END; [External] - PROCEDURE SetIV@1000000009(VAR DotNet_Array@1000000000 : Codeunit 3000); + [LineStart(374)] + PROCEDURE SetIV@1000000009(VAR DotNet_Array@1000000000 : Codeunit DotNet_Array); BEGIN DotNet_Array.Clone(DotNet_ArrayIV); END; [External] + [LineStart(378)] PROCEDURE EncryptTextBase64@1000000001(UnEncryptedText@1000000000 : Text;VAR EncryptedTextBase64@1000000003 : Text) : Boolean; VAR Result@1000000002 : Boolean; BEGIN - IF STRLEN(UnEncryptedText) > 0 THEN + if StrLen(UnEncryptedText) > 0 then Result := TryEncryptTextBase64(UnEncryptedText, EncryptedTextBase64); - CLEARLASTERROR; - EXIT(Result); + ClearLastError; + exit(Result); END; [External] + [LineStart(385)] PROCEDURE DecryptTextBase64@1000000002(EncryptedText@1000000000 : Text;VAR UnEncryptedText@1000000003 : Text) : Boolean; VAR Result@1000000002 : Boolean; BEGIN - IF STRLEN(EncryptedText) > 0 THEN + if StrLen(EncryptedText) > 0 then Result := TryDecryptTextBase64(EncryptedText, UnEncryptedText); - CLEARLASTERROR; - EXIT(Result); + ClearLastError; + exit(Result); END; [External] - PROCEDURE EncryptTempBlob@1000000006(VAR UnEncryptedTempBlob@1000000000 : Record 99008535;VAR EncryptedTempBlob@1000000003 : Record 99008535) : Boolean; + [LineStart(392)] + PROCEDURE EncryptTempBlob@1000000006(VAR UnEncryptedTempBlob@1000000000 : Record TempBlob;VAR EncryptedTempBlob@1000000003 : Record TempBlob) : Boolean; VAR Result@1000000002 : Boolean; BEGIN Result := TryEncryptTempBlob(UnEncryptedTempBlob, EncryptedTempBlob); - CLEARLASTERROR; - EXIT(Result); + ClearLastError; + exit(Result); END; [External] - PROCEDURE DecryptTempBlob@1000000005(VAR EncryptedTempBlob@1000000000 : Record 99008535;VAR DecryptedTempBlob@1000000003 : Record 99008535) : Boolean; + [LineStart(398)] + PROCEDURE DecryptTempBlob@1000000005(VAR EncryptedTempBlob@1000000000 : Record TempBlob;VAR DecryptedTempBlob@1000000003 : Record TempBlob) : Boolean; VAR Result@1000000002 : Boolean; BEGIN Result := TryDecryptTempBlob(EncryptedTempBlob, DecryptedTempBlob); - CLEARLASTERROR; - EXIT(Result); + ClearLastError; + exit(Result); END; [External] + [LineStart(404)] PROCEDURE EncryptStream@1000000003(VAR UnEncryptedStream@1000000002 : InStream;VAR EncryptedStream@1000000000 : OutStream) : Boolean; VAR Result@1000000003 : Boolean; BEGIN Result := TryEncryptStream(UnEncryptedStream, EncryptedStream); - CLEARLASTERROR; - EXIT(Result); + ClearLastError; + exit(Result); END; [External] + [LineStart(410)] PROCEDURE DecryptStream@1000000004(VAR EncryptedStream@1000000001 : InStream;VAR UnEncryptedStream@1000000000 : OutStream) : Boolean; VAR Result@1000000003 : Boolean; BEGIN Result := TryDecryptStream(EncryptedStream, UnEncryptedStream); - CLEARLASTERROR; - EXIT(Result); + ClearLastError; + exit(Result); // Private Interface ====================================================================================== END; + [LineStart(418)] LOCAL PROCEDURE KeyLengthInBytes@1000000017() : Integer; VAR Size@1000000000 : Integer; BEGIN - IF KeySize = 0 THEN + if KeySize = 0 then KeySize := 256; - EXIT(KeySize/8); + exit(KeySize/8); END; [TryFunction] + [LineStart(424)] LOCAL PROCEDURE TryEncryptTextBase64@1000000040(VAR UnEncryptedText@1000000012 : Text;VAR EncryptedTextBase64@1000000014 : Text); VAR OStream@1000000002 : OutStream; - TempBlobUnEncrypted@1000000001 : Record 99008535; - TempBlobEncrypted@1000000000 : Record 99008535; + TempBlobUnEncrypted@1000000001 : Record TempBlob; + TempBlobEncrypted@1000000000 : Record TempBlob; BEGIN // Push unencrypted text into tempblob - CLEAR(TempBlobUnEncrypted.Blob); - IF UnEncryptedText <> '' THEN BEGIN - TempBlobUnEncrypted.Blob.CREATEOUTSTREAM(OStream); - OStream.WRITETEXT(UnEncryptedText); - END; + Clear(TempBlobUnEncrypted.Blob); + if UnEncryptedText <> '' then begin + TempBlobUnEncrypted.Blob.CreateOutStream(OStream); + OStream.WriteText(UnEncryptedText); + end; // Encrypt - IF TryEncryptTempBlob(TempBlobUnEncrypted, TempBlobEncrypted) THEN - BEGIN + 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 else begin + ClearLastError; + Error('Encrypt failed'); + end; END; [TryFunction] + [LineStart(443)] 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; + TempBlobDecrypted@1000000006 : Record TempBlob; + TempBlobEncrypted@1000000005 : Record TempBlob; + DotNet_Encoding@1000000003 : Codeunit DotNet_Encoding; + DotNet_MemoryStream@1000000004 : Codeunit DotNet_MemoryStream; DotNetEncoding@1000000002 : DotNet "'mscorlib'.System.Text.Encoding"; DotNetMemoryStream@1000000007 : DotNet "'mscorlib'.System.IO.MemoryStream"; BEGIN // Anything to do? - IF EncryptedTextBase64 = '' THEN - EXIT; + 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 + if TryDecryptTempBlob(TempBlobEncrypted, TempBlobDecrypted) and TempBlobDecrypted.Blob.HasValue then + begin // Create a stream to read from decrypted blob - TempBlobDecrypted.Blob.CREATEINSTREAM(IStream); + TempBlobDecrypted.Blob.CreateInStream(IStream); // Read the decrypted bytes from the blob DotNet_MemoryStream.InitMemoryStream(); @@ -260,57 +289,60 @@ OBJECT Codeunit 50020 Symmetric Encryption Mgt DotNet_Encoding.GetEncoding(DotNetEncoding); DecryptedText := DotNetEncoding.GetString(DotNetMemoryStream.ToArray()); - END ELSE BEGIN - CLEARLASTERROR; - ERROR('Decrypt failed'); - END; + end else begin + ClearLastError; + Error('Decrypt failed'); + end; END; [TryFunction] - LOCAL PROCEDURE TryEncryptTempBlob@1000000012(VAR UnEncryptedTempBlob@1000000006 : Record 99008535;VAR EncryptedTempBlob@1000000002 : Record 99008535); + [LineStart(473)] + LOCAL PROCEDURE TryEncryptTempBlob@1000000012(VAR UnEncryptedTempBlob@1000000006 : Record TempBlob;VAR EncryptedTempBlob@1000000002 : Record TempBlob); VAR IStream@1000000001 : InStream; OStream@1000000000 : OutStream; BEGIN // Create a stream to read from unencrypted tempblob - UnEncryptedTempBlob.Blob.CREATEINSTREAM(IStream); + UnEncryptedTempBlob.Blob.CreateInStream(IStream); // Create a stream to write to encrypted tempblob - EncryptedTempBlob.INIT(); - EncryptedTempBlob.Blob.CREATEOUTSTREAM(OStream); + EncryptedTempBlob.Init(); + EncryptedTempBlob.Blob.CreateOutStream(OStream); // Encrypt - IF NOT TryEncryptStream(IStream, OStream) THEN - BEGIN - CLEARLASTERROR; - ERROR('Encrypt failed'); - END; + 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); + [LineStart(489)] + LOCAL PROCEDURE TryDecryptTempBlob@1000000007(VAR EncryptedTempBlob@1000000001 : Record TempBlob;VAR DecryptedTempBlob@1000000000 : Record TempBlob); VAR IStream@1000000008 : InStream; OStream@1000000007 : OutStream; BEGIN // Create a stream to read from encrypted tempblob - EncryptedTempBlob.Blob.CREATEINSTREAM(IStream); + EncryptedTempBlob.Blob.CreateInStream(IStream); // Create a stream to write to decrypted tempblob - CLEAR(DecryptedTempBlob.Blob); - DecryptedTempBlob.Blob.CREATEOUTSTREAM(OStream); + Clear(DecryptedTempBlob.Blob); + DecryptedTempBlob.Blob.CreateOutStream(OStream); // Decrypt - IF NOT TryDecryptStream(IStream, OStream) THEN - BEGIN - CLEARLASTERROR; - ERROR('Decrypt failed'); - END; + if not TryDecryptStream(IStream, OStream) then + begin + ClearLastError; + Error('Decrypt failed'); + end; END; [TryFunction] + [LineStart(505)] LOCAL PROCEDURE TryEncryptStream@1000000035(VAR UnEncryptedStream@1000000001 : InStream;VAR EncryptedStream@1000000000 : OutStream); VAR DotNetSymmetricAlgorithm@1000000021 : DotNet "'mscorlib'.System.Security.Cryptography.SymmetricAlgorithm"; @@ -321,19 +353,19 @@ OBJECT Codeunit 50020 Symmetric Encryption Mgt 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; + DotNet_SymmetricAlgorithm@1000000012 : Codeunit DotNet_SymmetricAlgorithm; + DotNet_ICryptoTransform@1000000011 : Codeunit DotNet_ICryptoTransform; + DotNet_CryptoStream@1000000010 : Codeunit DotNet_CryptoStream; + DotNet_Encoding@1000000009 : Codeunit DotNet_Encoding; + DotNet_StreamReader@1000000008 : Codeunit DotNet_StreamReader; + DotNet_StreamWriter@1000000007 : Codeunit DotNet_StreamWriter; + DotNet_StreamEncrypted@1000000005 : Codeunit DotNet_Stream; + DotNet_StreamDecrypted@1000000004 : Codeunit DotNet_Stream; + DotNet_Array@1000000002 : Codeunit DotNet_Array; BytesRead@1000000003 : Integer; BEGIN - IF TryCreateSymmetricAlgorithm(DotNet_SymmetricAlgorithm) THEN BEGIN + if TryCreateSymmetricAlgorithm(DotNet_SymmetricAlgorithm) then begin // encoding used for transforms DotNet_Encoding.UTF8; @@ -359,11 +391,11 @@ OBJECT Codeunit 50020 Symmetric Encryption Mgt DotNet_Array.GetArray(DotNetArray); // encrypt - REPEAT + repeat BytesRead := DotNetStreamReader.BaseStream.Read(DotNetArray, 0, DotNetArray.Length); - IF BytesRead > 0 THEN + if BytesRead > 0 then DotNetStreamWriter.BaseStream.Write(DotNetArray, 0, BytesRead); - UNTIL BytesRead < 1; + until BytesRead < 1; DotNetStreamWriter.Flush(); // dispose @@ -372,10 +404,11 @@ OBJECT Codeunit 50020 Symmetric Encryption Mgt DotNetCryptoStream.Dispose(); DotNetICryptoTransform.Dispose(); DotNetSymmetricAlgorithm.Dispose(); - END; + end; END; [TryFunction] + [LineStart(548)] LOCAL PROCEDURE TryDecryptStream@1000000036(VAR EncryptedStream@1000000001 : InStream;VAR DecryptedStream@1000000000 : OutStream); VAR DotNetSymmetricAlgorithm@1000000010 : DotNet "'mscorlib'.System.Security.Cryptography.SymmetricAlgorithm"; @@ -386,19 +419,19 @@ OBJECT Codeunit 50020 Symmetric Encryption Mgt 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; + DotNet_SymmetricAlgorithm@1000000002 : Codeunit DotNet_SymmetricAlgorithm; + DotNet_ICryptoTransform@1000000009 : Codeunit DotNet_ICryptoTransform; + DotNet_CryptoStream@1000000011 : Codeunit DotNet_CryptoStream; + DotNet_Encoding@1000000012 : Codeunit DotNet_Encoding; + DotNet_StreamReader@1000000013 : Codeunit DotNet_StreamReader; + DotNet_StreamWriter@1000000014 : Codeunit DotNet_StreamWriter; + DotNet_StreamEncrypted@1000000017 : Codeunit DotNet_Stream; + DotNet_StreamDecrypted@1000000018 : Codeunit DotNet_Stream; + DotNet_Array@1000000015 : Codeunit DotNet_Array; BytesRead@1000000003 : Integer; BEGIN - IF TryCreateSymmetricAlgorithm(DotNet_SymmetricAlgorithm) THEN BEGIN + if TryCreateSymmetricAlgorithm(DotNet_SymmetricAlgorithm) then begin // encoding used for transforms DotNet_Encoding.UTF8; @@ -424,11 +457,11 @@ OBJECT Codeunit 50020 Symmetric Encryption Mgt DotNet_Array.GetArray(DotNetArray); // decrypt - REPEAT + repeat BytesRead := DotNetStreamReader.BaseStream.Read(DotNetArray, 0, DotNetArray.Length); - IF BytesRead > 0 THEN + if BytesRead > 0 then DotNetStreamWriter.BaseStream.Write(DotNetArray, 0, BytesRead); - UNTIL BytesRead < 1; + until BytesRead < 1; DotNetStreamWriter.Flush(); DotNetStreamWriter.Close(); @@ -438,41 +471,42 @@ OBJECT Codeunit 50020 Symmetric Encryption Mgt DotNetCryptoStream.Dispose(); DotNetICryptoTransform.Dispose(); DotNetSymmetricAlgorithm.Dispose(); - END; + end; END; [TryFunction] - LOCAL PROCEDURE TryCreateSymmetricAlgorithm@1000000025(VAR DotNet_SymmetricAlgorithm@1000000005 : Codeunit 50010); + [LineStart(592)] + LOCAL PROCEDURE TryCreateSymmetricAlgorithm@1000000025(VAR DotNet_SymmetricAlgorithm@1000000005 : Codeunit DotNet_SymmetricAlgorithm); BEGIN - IF (DotNet_ArrayIV.Length = 0) OR (DotNet_ArrayIV.Length = 0) THEN - ERROR(E_NO_CIPHER); + if (DotNet_ArrayIV.Length = 0) or (DotNet_ArrayIV.Length = 0) then + Error(E_NO_CIPHER); - DotNet_SymmetricAlgorithm.Create(Algorithm); - IF Mode > 0 THEN DotNet_SymmetricAlgorithm.SetMode(Mode); - IF BlockSize > 0 THEN DotNet_SymmetricAlgorithm.SetBlockSize(BlockSize); - IF Padding > 0 THEN DotNet_SymmetricAlgorithm.SetPadding(Padding); - IF KeySize > 0 THEN DotNet_SymmetricAlgorithm.SetKeySize(KeySize); + DotNet_SymmetricAlgorithm.Create(SymmetricAlgorithm); + if Mode > 0 then DotNet_SymmetricAlgorithm.SetMode(Mode); + if BlockSize > 0 then DotNet_SymmetricAlgorithm.SetBlockSize(BlockSize); + if Padding > 0 then DotNet_SymmetricAlgorithm.SetPadding(Padding); + 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); + [LineStart(605)] + LOCAL PROCEDURE TrySetCipher@1000000016(VAR TempBlob@1000000000 : Record TempBlob); VAR IStream@1000000001 : InStream; - DotNet_HashAlgorithm@1000000006 : Codeunit 50012; - DotNet_HashAlgorithmOption@1000000008 : 'SHA1,MD5,SHA256,SHA384,SHA512'; - DotNet_ArrayHashBytes@1000000012 : Codeunit 3000; + DotNet_HashAlgorithm@1000000006 : Codeunit DotNet_HashAlgorithm; + DotNet_ArrayHashBytes@1000000012 : Codeunit DotNet_Array; 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); + TempBlob.Blob.CreateInStream(IStream); - DotNet_HashAlgorithm.Create(DotNet_HashAlgorithmOption::SHA384); + DotNet_HashAlgorithm.Create('SHA384'); DotNet_HashAlgorithm.ComputeHashFromInStream(IStream, DotNet_ArrayHashBytes); DotNet_ArrayKey.ByteArray(KeyLengthInBytes); 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 index 2b3f66e..a129735 100644 --- a/Test/COD51010.TXT +++ b/Test/COD51010.TXT @@ -2,9 +2,8 @@ OBJECT Codeunit 51010 Test_DotNet_SymmetricAlgorithm { OBJECT-PROPERTIES { - Date=11/13/18; - Time=[ 4:00:25 PM]; - Modified=Yes; + Date=; + Time=; Version List=; } PROPERTIES diff --git a/Test/COD51012.TXT b/Test/COD51012.TXT index 1014563..cf5b99f 100644 --- a/Test/COD51012.TXT +++ b/Test/COD51012.TXT @@ -2,9 +2,8 @@ OBJECT Codeunit 51012 Test_DotNet_HashAlgorithm { OBJECT-PROPERTIES { - Date=11/13/18; - Time=[ 4:19:06 PM]; - Modified=Yes; + Date=; + Time=; Version List=; } PROPERTIES diff --git a/Test/COD51013.TXT b/Test/COD51013.TXT index 59b2133..d8dc289 100644 --- a/Test/COD51013.TXT +++ b/Test/COD51013.TXT @@ -2,9 +2,8 @@ OBJECT Codeunit 51013 Test_DotNet_ICryptoTransform { OBJECT-PROPERTIES { - Date=11/13/18; - Time=[ 8:23:46 PM]; - Modified=Yes; + Date=; + Time=; Version List=; } PROPERTIES diff --git a/Test/COD51014.TXT b/Test/COD51014.TXT index 91d3f66..ccdfd7e 100644 --- a/Test/COD51014.TXT +++ b/Test/COD51014.TXT @@ -2,9 +2,8 @@ OBJECT Codeunit 51014 Test_DotNet_CryptoStream { OBJECT-PROPERTIES { - Date=11/13/18; - Time=[ 4:42:05 PM]; - Modified=Yes; + Date=; + Time=; Version List=; } PROPERTIES diff --git a/Test/COD51020.TXT b/Test/COD51020.TXT index 9e27765..1b355d5 100644 --- a/Test/COD51020.TXT +++ b/Test/COD51020.TXT @@ -2,9 +2,8 @@ OBJECT Codeunit 51020 Test_Symmetric_Encryption_Mgt { OBJECT-PROPERTIES { - Date=11/13/18; - Time=[ 3:22:43 PM]; - Modified=Yes; + Date=; + Time=; Version List=; } PROPERTIES From 2a8cafa6fa74dcce85ee91633da5e3a904e27b69 Mon Sep 17 00:00:00 2001 From: Phil Rios <30962795+quadfin@users.noreply.github.com> Date: Fri, 15 Feb 2019 16:42:50 -0800 Subject: [PATCH 3/5] Removed properties --- BaseApp/COD3000.TXT | 5 ++--- BaseApp/COD3025.TXT | 5 ++--- BaseApp/COD3027.TXT | 5 ++--- BaseApp/COD50010.TXT | 5 ++--- BaseApp/COD50012.TXT | 5 ++--- BaseApp/COD50013.TXT | 5 ++--- BaseApp/COD50014.TXT | 5 ++--- BaseApp/COD50015.TXT | 5 ++--- BaseApp/COD50016.TXT | 5 ++--- BaseApp/COD50020.TXT | 5 ++--- 10 files changed, 20 insertions(+), 30 deletions(-) diff --git a/BaseApp/COD3000.TXT b/BaseApp/COD3000.TXT index d1aac3c..180487b 100644 --- a/BaseApp/COD3000.TXT +++ b/BaseApp/COD3000.TXT @@ -2,9 +2,8 @@ OBJECT Codeunit 3000 DotNet_Array { OBJECT-PROPERTIES { - Date=20181113D; - Time=104906T; - Modified=true; + Date=; + Time=; Version List=; } PROPERTIES diff --git a/BaseApp/COD3025.TXT b/BaseApp/COD3025.TXT index 2c1f798..523ad3b 100644 --- a/BaseApp/COD3025.TXT +++ b/BaseApp/COD3025.TXT @@ -2,9 +2,8 @@ OBJECT Codeunit 3025 DotNet_StreamWriter { OBJECT-PROPERTIES { - Date=20181113D; - Time=102817T; - Modified=true; + Date=; + Time=; Version List=; } PROPERTIES diff --git a/BaseApp/COD3027.TXT b/BaseApp/COD3027.TXT index ed147fa..8fb2f00 100644 --- a/BaseApp/COD3027.TXT +++ b/BaseApp/COD3027.TXT @@ -2,9 +2,8 @@ OBJECT Codeunit 3027 DotNet_StreamReader { OBJECT-PROPERTIES { - Date=20181113D; - Time=102833T; - Modified=true; + Date=; + Time=; Version List=; } PROPERTIES diff --git a/BaseApp/COD50010.TXT b/BaseApp/COD50010.TXT index 1bb14ec..59d1fb3 100644 --- a/BaseApp/COD50010.TXT +++ b/BaseApp/COD50010.TXT @@ -2,9 +2,8 @@ OBJECT Codeunit 50010 DotNet_SymmetricAlgorithm { OBJECT-PROPERTIES { - Date=20190215D; - Time=110335.543T; - Modified=true; + Date=; + Time=; Version List=; } PROPERTIES diff --git a/BaseApp/COD50012.TXT b/BaseApp/COD50012.TXT index 49faacb..39de8a0 100644 --- a/BaseApp/COD50012.TXT +++ b/BaseApp/COD50012.TXT @@ -2,9 +2,8 @@ OBJECT Codeunit 50012 DotNet_HashAlgorithm { OBJECT-PROPERTIES { - Date=20190215D; - Time=115932.293T; - Modified=true; + Date=; + Time=; Version List=; } PROPERTIES diff --git a/BaseApp/COD50013.TXT b/BaseApp/COD50013.TXT index 3b29d49..5b14509 100644 --- a/BaseApp/COD50013.TXT +++ b/BaseApp/COD50013.TXT @@ -2,9 +2,8 @@ OBJECT Codeunit 50013 DotNet_ICryptoTransform { OBJECT-PROPERTIES { - Date=20181106D; - Time=201927T; - Modified=true; + Date=; + Time=; Version List=; } PROPERTIES diff --git a/BaseApp/COD50014.TXT b/BaseApp/COD50014.TXT index 856c144..ce7b4dd 100644 --- a/BaseApp/COD50014.TXT +++ b/BaseApp/COD50014.TXT @@ -2,9 +2,8 @@ OBJECT Codeunit 50014 DotNet_CryptoStream { OBJECT-PROPERTIES { - Date=20181107D; - Time=090928T; - Modified=true; + Date=; + Time=; Version List=; } PROPERTIES diff --git a/BaseApp/COD50015.TXT b/BaseApp/COD50015.TXT index 8feb756..775681a 100644 --- a/BaseApp/COD50015.TXT +++ b/BaseApp/COD50015.TXT @@ -2,9 +2,8 @@ OBJECT Codeunit 50015 DotNet_CipherMode { OBJECT-PROPERTIES { - Date=20190215D; - Time=153450.770T; - Modified=true; + Date=; + Time=; Version List=; } PROPERTIES diff --git a/BaseApp/COD50016.TXT b/BaseApp/COD50016.TXT index bcc7988..d937244 100644 --- a/BaseApp/COD50016.TXT +++ b/BaseApp/COD50016.TXT @@ -2,9 +2,8 @@ OBJECT Codeunit 50016 DotNet_PaddingMode { OBJECT-PROPERTIES { - Date=20190215D; - Time=154300.203T; - Modified=true; + Date=; + Time=; Version List=; } PROPERTIES diff --git a/BaseApp/COD50020.TXT b/BaseApp/COD50020.TXT index 6ec5d3f..0d03394 100644 --- a/BaseApp/COD50020.TXT +++ b/BaseApp/COD50020.TXT @@ -2,9 +2,8 @@ OBJECT Codeunit 50020 Symmetric Encryption Mgt { OBJECT-PROPERTIES { - Date=20190215D; - Time=161812.983T; - Modified=true; + Date=; + Time=; Version List=; } PROPERTIES From ba2ff79b5a8199be8ec71c00bf896731b0307a35 Mon Sep 17 00:00:00 2001 From: Phil Rios <30962795+quadfin@users.noreply.github.com> Date: Sat, 16 Feb 2019 13:12:50 -0800 Subject: [PATCH 4/5] Added wrapper DotNet_CryptoStreamMode Addded wrappers for CryptoStream properties Updated interfaces to use enums Updated tests --- BaseApp/COD3025.TXT | 20 +++--- BaseApp/COD3027.TXT | 22 +++--- BaseApp/COD50010.TXT | 92 ++++++++++++++---------- BaseApp/COD50012.TXT | 14 ++-- BaseApp/COD50013.TXT | 6 +- BaseApp/COD50014.TXT | 69 ++++++++++++++++-- BaseApp/COD50015.TXT | 47 ++++++------ BaseApp/COD50016.TXT | 49 +++++++------ BaseApp/COD50017.TXT | 54 ++++++++++++++ BaseApp/COD50020.TXT | 84 ++++++++++------------ Test/COD51010.TXT | 168 ++++++++++++++++++++++++++----------------- Test/COD51012.TXT | 87 +++++++++++----------- Test/COD51013.TXT | 19 ++--- Test/COD51014.TXT | 68 +++++++----------- Test/COD51020.TXT | 133 +++++++++++++++++----------------- 15 files changed, 536 insertions(+), 396 deletions(-) create mode 100644 BaseApp/COD50017.TXT diff --git a/BaseApp/COD3025.TXT b/BaseApp/COD3025.TXT index 523ad3b..bf92986 100644 --- a/BaseApp/COD3025.TXT +++ b/BaseApp/COD3025.TXT @@ -18,21 +18,21 @@ OBJECT Codeunit 3025 DotNet_StreamWriter DotNetStreamWriter@1001 : DotNet "'mscorlib'.System.IO.StreamWriter"; [External] - [LineStart(57)] + [LineStart(2)] PROCEDURE Write@6(Text@1000 : Text); BEGIN DotNetStreamWriter.Write(Text); END; [External] - [LineStart(60)] + [LineStart(5)] PROCEDURE WriteLine@2(LineText@1000 : Text); BEGIN DotNetStreamWriter.WriteLine(LineText); END; [External] - [LineStart(63)] + [LineStart(8)] PROCEDURE StreamWriter@1(VAR OutStream@1000 : OutStream;DotNet_Encoding@1001 : Codeunit DotNet_Encoding); VAR DotNetEncoding@1002 : DotNet "'mscorlib'.System.Text.Encoding"; @@ -42,7 +42,7 @@ OBJECT Codeunit 3025 DotNet_StreamWriter END; [External] - [LineStart(67)] + [LineStart(12)] PROCEDURE StreamWriterFromDotNetStream@1000000001(VAR DotNet_Stream@1000 : Codeunit DotNet_Stream;DotNet_Encoding@1001 : Codeunit DotNet_Encoding); VAR DotNetEncoding@1002 : DotNet "'mscorlib'.System.Text.Encoding"; @@ -54,40 +54,40 @@ OBJECT Codeunit 3025 DotNet_StreamWriter END; [External] - [LineStart(72)] + [LineStart(17)] PROCEDURE StreamWriterWithDefaultEncoding@7(VAR OutStream@1000 : OutStream); BEGIN DotNetStreamWriter := DotNetStreamWriter.StreamWriter(OutStream); END; [External] - [LineStart(75)] + [LineStart(20)] PROCEDURE Flush@3(); BEGIN DotNetStreamWriter.Flush; END; [External] - [LineStart(78)] + [LineStart(23)] PROCEDURE Close@4(); BEGIN DotNetStreamWriter.Close; END; [External] - [LineStart(81)] + [LineStart(26)] PROCEDURE Dispose@5(); BEGIN DotNetStreamWriter.Dispose; END; - [LineStart(84)] + [LineStart(29)] PROCEDURE GetStreamWriter@1000000000(VAR DotNetStreamWriter2@1000000000 : DotNet "'mscorlib'.System.IO.StreamWriter"); BEGIN DotNetStreamWriter2 := DotNetStreamWriter; END; - [LineStart(87)] + [LineStart(32)] PROCEDURE SetStreamWriter@1000000002(VAR DotNetStreamWriter2@1000000000 : DotNet "'mscorlib'.System.IO.StreamWriter"); BEGIN DotNetStreamWriter := DotNetStreamWriter2; diff --git a/BaseApp/COD3027.TXT b/BaseApp/COD3027.TXT index 8fb2f00..4375dbd 100644 --- a/BaseApp/COD3027.TXT +++ b/BaseApp/COD3027.TXT @@ -18,7 +18,7 @@ OBJECT Codeunit 3027 DotNet_StreamReader DotNetStreamReader@1000 : DotNet "'mscorlib'.System.IO.StreamReader"; [External] - [LineStart(92)] + [LineStart(37)] PROCEDURE StreamReader@1(VAR InputStream@1000 : InStream;DotNet_Encoding@1001 : Codeunit DotNet_Encoding); VAR DotNetEncoding@1002 : DotNet "'mscorlib'.System.Text.Encoding"; @@ -28,7 +28,7 @@ OBJECT Codeunit 3027 DotNet_StreamReader END; [External] - [LineStart(96)] + [LineStart(41)] PROCEDURE StreamReaderFromDotNetStream@1000000000(VAR DotNet_Stream@1000 : Codeunit DotNet_Stream;DotNet_Encoding@1001 : Codeunit DotNet_Encoding); VAR DotNetEncoding@1002 : DotNet "'mscorlib'.System.Text.Encoding"; @@ -41,61 +41,61 @@ OBJECT Codeunit 3027 DotNet_StreamReader END; [External] - [LineStart(102)] + [LineStart(47)] PROCEDURE StreamReaderDetectEncoding@2(VAR InputStream@1000 : InStream;DetectEncodingFromByteOrderMarks@1001 : Boolean); BEGIN DotNetStreamReader := DotNetStreamReader.StreamReader(InputStream,DetectEncodingFromByteOrderMarks); END; [External] - [LineStart(105)] + [LineStart(50)] PROCEDURE Close@3(); BEGIN DotNetStreamReader.Close; END; [External] - [LineStart(108)] + [LineStart(53)] PROCEDURE Dispose@4(); BEGIN DotNetStreamReader.Dispose; END; [External] - [LineStart(111)] + [LineStart(56)] PROCEDURE EndOfStream@6() : Boolean; BEGIN exit(DotNetStreamReader.EndOfStream); END; [External] - [LineStart(114)] + [LineStart(59)] PROCEDURE CurrentEncoding@7(VAR DotNet_Encoding@1000 : Codeunit DotNet_Encoding); BEGIN DotNet_Encoding.SetEncoding(DotNetStreamReader.CurrentEncoding); END; [External] - [LineStart(117)] + [LineStart(62)] PROCEDURE ReadLine@8() : Text; BEGIN exit(DotNetStreamReader.ReadLine); END; [External] - [LineStart(120)] + [LineStart(65)] PROCEDURE ReadToEnd@9() : Text; BEGIN exit(DotNetStreamReader.ReadToEnd); END; - [LineStart(123)] + [LineStart(68)] PROCEDURE GetStreamReader@1000000001(VAR DotNetStreamReader2@1000000000 : DotNet "'mscorlib'.System.IO.StreamReader"); BEGIN DotNetStreamReader2 := DotNetStreamReader; END; - [LineStart(126)] + [LineStart(71)] PROCEDURE SetStreamReader@1000000002(VAR DotNetStreamReader2@1000000000 : DotNet "'mscorlib'.System.IO.StreamReader"); BEGIN DotNetStreamReader := DotNetStreamReader2; diff --git a/BaseApp/COD50010.TXT b/BaseApp/COD50010.TXT index 59d1fb3..0a65352 100644 --- a/BaseApp/COD50010.TXT +++ b/BaseApp/COD50010.TXT @@ -16,38 +16,38 @@ OBJECT Codeunit 50010 DotNet_SymmetricAlgorithm { VAR DotNetSymmetricAlgorithm@1000000000 : DotNet "'mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089'.System.Security.Cryptography.SymmetricAlgorithm"; - EALGORITHM@1000000001 : TextConst 'ENU=Invalid Algorithm'; + E_INVALID_ALGORITHM@1000000001 : TextConst 'ENU=Invalid Algorithm'; [External] - [LineStart(131)] + [LineStart(76)] PROCEDURE GetBlockSize@1000000000() : Integer; BEGIN exit(DotNetSymmetricAlgorithm.BlockSize); END; [External] - [LineStart(134)] + [LineStart(79)] PROCEDURE SetBlockSize@1000000027(BlockSize@1000000000 : Integer); BEGIN DotNetSymmetricAlgorithm.BlockSize := BlockSize; END; [External] - [LineStart(137)] + [LineStart(82)] PROCEDURE GetFeedbackSize@1000000007() : Integer; BEGIN exit(DotNetSymmetricAlgorithm.FeedbackSize); END; [External] - [LineStart(140)] + [LineStart(85)] PROCEDURE SetFeedbackSize@1000000006(FeedbackSize@1000000000 : Integer); BEGIN DotNetSymmetricAlgorithm.FeedbackSize := FeedbackSize; END; [External] - [LineStart(143)] + [LineStart(88)] PROCEDURE GetIV@1000000001(VAR DotNet_Array@1000000000 : Codeunit DotNet_Array); VAR DotNetArray@1000000001 : DotNet "'mscorlib'.System.Array"; @@ -58,7 +58,7 @@ OBJECT Codeunit 50010 DotNet_SymmetricAlgorithm END; [External] - [LineStart(148)] + [LineStart(93)] PROCEDURE SetIV@1000000023(VAR DotNet_Array@1000000000 : Codeunit DotNet_Array); VAR DotNetArray@1000000001 : DotNet "'mscorlib'.System.Array"; @@ -68,7 +68,7 @@ OBJECT Codeunit 50010 DotNet_SymmetricAlgorithm END; [External] - [LineStart(152)] + [LineStart(97)] PROCEDURE GetKey@1000000002(VAR DotNet_Array@1000000000 : Codeunit DotNet_Array); VAR DotNetArray@1000000001 : DotNet "'mscorlib'.System.Array"; @@ -79,7 +79,7 @@ OBJECT Codeunit 50010 DotNet_SymmetricAlgorithm END; [External] - [LineStart(157)] + [LineStart(102)] PROCEDURE SetKey@1000000021(VAR DotNet_Array@1000000000 : Codeunit DotNet_Array); VAR DotNetArray@1000000001 : DotNet "'mscorlib'.System.Array"; @@ -89,84 +89,104 @@ OBJECT Codeunit 50010 DotNet_SymmetricAlgorithm END; [External] - [LineStart(161)] + [LineStart(106)] PROCEDURE GetKeySize@1000000003() : Integer; BEGIN exit(DotNetSymmetricAlgorithm.KeySize); END; [External] - [LineStart(164)] + [LineStart(109)] PROCEDURE SetKeySize@1000000018(KeySize@1000000000 : Integer); BEGIN DotNetSymmetricAlgorithm.KeySize := KeySize; END; [External] - [LineStart(167)] - PROCEDURE GetMode@1000000004(VAR Mode@1000000000 : ',CBC,ECB,OFB,CFB,CTS'); + [LineStart(112)] + PROCEDURE GetMode@1000000004(VAR DotNet_CipherMode@1000000000 : Codeunit DotNet_CipherMode); VAR - CipherMode@1000000001 : Integer; + DotNetCipherMode@1000000001 : DotNet "'mscorlib'.System.Security.Cryptography.CipherMode"; BEGIN - CipherMode := DotNetSymmetricAlgorithm.Mode; - Mode := CipherMode; + DotNetCipherMode := DotNetSymmetricAlgorithm.Mode; + DotNet_CipherMode.SetCipherMode(DotNetCipherMode); END; [External] - [LineStart(171)] - PROCEDURE SetMode@1000000020(Mode@1000000000 : ',CBC,ECB,OFB,CFB,CTS'); + [LineStart(116)] + PROCEDURE SetMode@1000000020(VAR DotNet_CipherMode@1000000000 : Codeunit DotNet_CipherMode); VAR - CipherMode@1000000001 : Integer; + DotNetCipherMode@1000000001 : DotNet "'mscorlib'.System.Security.Cryptography.CipherMode"; BEGIN - CipherMode := Mode; - DotNetSymmetricAlgorithm.Mode := CipherMode; + DotNet_CipherMode.GetCipherMode(DotNetCipherMode); + DotNetSymmetricAlgorithm.Mode := DotNetCipherMode; END; [External] - [LineStart(175)] - PROCEDURE GetPadding@1000000005(VAR Padding@1000000000 : ',None,PKCS7,Zeros,ANSIX923,ISO10126'); + [LineStart(120)] + PROCEDURE GetPadding@1000000005(VAR DotNet_PaddingMode@1000000001 : Codeunit DotNet_PaddingMode) : Integer; VAR - PaddingMode@1000000001 : Integer; + DotNetPaddingMode@1000000000 : DotNet "'mscorlib'.System.Security.Cryptography.PaddingMode"; BEGIN - PaddingMode := DotNetSymmetricAlgorithm.Padding; - Padding := PaddingMode; + DotNetPaddingMode := DotNetSymmetricAlgorithm.Padding; + DotNet_PaddingMode.SetPaddingMode(DotNetPaddingMode); END; [External] - [LineStart(179)] - PROCEDURE SetPadding@1000000019(Padding@1000000000 : ',None,PKCS7,Zeros,ANSIX923,ISO10126'); + [LineStart(124)] + PROCEDURE SetPadding@1000000019(VAR DotNet_PaddingMode@1000000002 : Codeunit DotNet_PaddingMode); VAR - PaddingMode@1000000001 : Integer; + DotNetPaddingMode@1000000001 : DotNet "'mscorlib'.System.Security.Cryptography.PaddingMode"; BEGIN - PaddingMode := Padding; - DotNetSymmetricAlgorithm.Padding := PaddingMode; + DotNet_PaddingMode.GetPaddingMode(DotNetPaddingMode); + DotNetSymmetricAlgorithm.Padding := DotNetPaddingMode; END; [External] - [LineStart(183)] + [LineStart(128)] PROCEDURE Create@1000000028(Algorithm@1000000000 : Text); BEGIN if not (UpperCase(Algorithm) in ['AES','DES','RC2','RIJNDAEL','TRIPLEDES']) then - Error(EALGORITHM); + Error(E_INVALID_ALGORITHM); Dispose(); DotNetSymmetricAlgorithm := DotNetSymmetricAlgorithm.Create(Algorithm); END; [External] - [LineStart(189)] + [LineStart(134)] PROCEDURE Dispose@1000000008(); BEGIN if not IsNull(DotNetSymmetricAlgorithm) then DotNetSymmetricAlgorithm.Dispose(); END; - [LineStart(193)] + [External] + [LineStart(138)] + PROCEDURE CreateEncryptor@1000000009(VAR DotNet_ICryptoTransform@1000000000 : Codeunit DotNet_ICryptoTransform); + VAR + DotNetICryptoTransform@1000000001 : DotNet "'mscorlib'.System.Security.Cryptography.ICryptoTransform"; + BEGIN + DotNetICryptoTransform := DotNetSymmetricAlgorithm.CreateEncryptor(); + DotNet_ICryptoTransform.SetICryptoTransform(DotNetICryptoTransform); + END; + + [External] + [LineStart(142)] + PROCEDURE CreateDecryptor@1000000015(VAR DotNet_ICryptoTransform@1000000000 : Codeunit DotNet_ICryptoTransform); + VAR + DotNetICryptoTransform@1000000001 : DotNet "'mscorlib'.System.Security.Cryptography.ICryptoTransform"; + BEGIN + DotNetICryptoTransform := DotNetSymmetricAlgorithm.CreateDecryptor(); + DotNet_ICryptoTransform.SetICryptoTransform(DotNetICryptoTransform); + END; + + [LineStart(146)] 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; - [LineStart(196)] + [LineStart(149)] PROCEDURE SetSymmetricAlgorithm@1000000014(VAR DotNetSymmetricAlgorithm2@1000000000 : DotNet "'mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089'.System.Security.Cryptography.SymmetricAlgorithm"); BEGIN DotNetSymmetricAlgorithm := DotNetSymmetricAlgorithm2; diff --git a/BaseApp/COD50012.TXT b/BaseApp/COD50012.TXT index 39de8a0..8a340c7 100644 --- a/BaseApp/COD50012.TXT +++ b/BaseApp/COD50012.TXT @@ -19,7 +19,7 @@ OBJECT Codeunit 50012 DotNet_HashAlgorithm EALGORITHM@1000000001 : TextConst 'ENU=Invalid Hash Algorithm'; [External] - [LineStart(201)] + [LineStart(154)] PROCEDURE Create@1000000005(HashAlgorithm@1000000000 : Text); BEGIN if not (UpperCase(HashAlgorithm) in ['SHA1','MD5','SHA256','SHA384','SHA512']) then @@ -28,7 +28,7 @@ OBJECT Codeunit 50012 DotNet_HashAlgorithm END; [External] - [LineStart(206)] + [LineStart(159)] PROCEDURE ComputeHash@1000000001(VAR DotNet_ArrayData@1000000001 : Codeunit DotNet_Array;VAR DotNet_ArrayHash@1000 : Codeunit DotNet_Array); VAR DotNetArray@1000000000 : DotNet "'mscorlib'.System.Array"; @@ -38,7 +38,7 @@ OBJECT Codeunit 50012 DotNet_HashAlgorithm END; [External] - [LineStart(210)] + [LineStart(163)] PROCEDURE ComputeHashFromText@1000000000(VAR Text@1000000001 : Text;VAR DotNet_Array@1000 : Codeunit DotNet_Array); VAR DotNetEncoding@1000000002 : DotNet "'mscorlib'.System.Text.Encoding"; @@ -52,26 +52,26 @@ OBJECT Codeunit 50012 DotNet_HashAlgorithm END; [External] - [LineStart(217)] + [LineStart(170)] PROCEDURE ComputeHashFromInStream@5(VAR IStream@1000000001 : InStream;VAR DotNet_Array@1000 : Codeunit DotNet_Array); BEGIN DotNet_Array.SetArray(DotNetHashAlgorithm.ComputeHash(IStream)); END; [External] - [LineStart(220)] + [LineStart(173)] PROCEDURE Dispose@1000000006(); BEGIN DotNetHashAlgorithm.Dispose(); END; - [LineStart(223)] + [LineStart(176)] PROCEDURE GetHashAlgorithm@2(VAR DotNetHashAlgorithm2@1000000001 : DotNet "'mscorlib'.System.Security.Cryptography.HashAlgorithm"); BEGIN DotNetHashAlgorithm2 := DotNetHashAlgorithm; END; - [LineStart(226)] + [LineStart(179)] PROCEDURE SetHashAlgorithm@3(VAR DotNetHashAlgorithm2@1000000000 : DotNet "'mscorlib'.System.Security.Cryptography.HashAlgorithm"); BEGIN DotNetHashAlgorithm := DotNetHashAlgorithm2; diff --git a/BaseApp/COD50013.TXT b/BaseApp/COD50013.TXT index 5b14509..77d1212 100644 --- a/BaseApp/COD50013.TXT +++ b/BaseApp/COD50013.TXT @@ -18,19 +18,19 @@ OBJECT Codeunit 50013 DotNet_ICryptoTransform DotNetICryptoTransform@1000000000 : DotNet "'mscorlib'.System.Security.Cryptography.ICryptoTransform"; [External] - [LineStart(231)] + [LineStart(184)] PROCEDURE Dispose@1000000006(); BEGIN DotNetICryptoTransform.Dispose() END; - [LineStart(234)] + [LineStart(187)] PROCEDURE GetICryptoTransform@2(VAR DotNetICryptoTransform2@1000000001 : DotNet "'mscorlib'.System.Security.Cryptography.ICryptoTransform"); BEGIN DotNetICryptoTransform2 := DotNetICryptoTransform END; - [LineStart(237)] + [LineStart(190)] PROCEDURE SetICryptoTransform@3(VAR DotNetICryptoTransform2@1000000000 : DotNet "'mscorlib'.System.Security.Cryptography.ICryptoTransform"); BEGIN DotNetICryptoTransform := DotNetICryptoTransform2 diff --git a/BaseApp/COD50014.TXT b/BaseApp/COD50014.TXT index ce7b4dd..4e6367e 100644 --- a/BaseApp/COD50014.TXT +++ b/BaseApp/COD50014.TXT @@ -18,7 +18,21 @@ OBJECT Codeunit 50014 DotNet_CryptoStream DotNetCryptoStream@1000000000 : DotNet "'mscorlib'.System.Security.Cryptography.CryptoStream"; [External] - [LineStart(242)] + [LineStart(195)] + PROCEDURE CryptoStream@1000000001(VAR DotNet_Stream@1000000000 : Codeunit DotNet_Stream;VAR DotNet_ICryptoTransform@1000000001 : Codeunit DotNet_ICryptoTransform;VAR DotNet_CryptoStreamMode@1000000005 : Codeunit DotNet_CryptoStreamMode); + 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] + [LineStart(201)] PROCEDURE CryptoInStream@1000000005(IStream@1000000000 : InStream;VAR DotNet_ICryptoTransform@1000000001 : Codeunit DotNet_ICryptoTransform); VAR DotNetICryptoTransform@1000000004 : DotNet "'mscorlib'.System.Security.Cryptography.ICryptoTransform"; @@ -29,7 +43,7 @@ OBJECT Codeunit 50014 DotNet_CryptoStream END; [External] - [LineStart(246)] + [LineStart(205)] PROCEDURE CryptoOutStream@1000000000(OStream@1000000000 : OutStream;VAR DotNet_ICryptoTransform@1000000001 : Codeunit DotNet_ICryptoTransform); VAR DotNetICryptoTransform@1000000004 : DotNet "'mscorlib'.System.Security.Cryptography.ICryptoTransform"; @@ -40,19 +54,64 @@ OBJECT Codeunit 50014 DotNet_CryptoStream END; [External] - [LineStart(250)] + [LineStart(209)] + PROCEDURE CanRead@1000000002() : Boolean; + BEGIN + if not IsNull(DotNetCryptoStream) then + exit(DotNetCryptoStream.CanRead); + exit(false); + END; + + [External] + [LineStart(214)] + PROCEDURE CanSeek@1000000003() : Boolean; + BEGIN + if not IsNull(DotNetCryptoStream) then + exit(DotNetCryptoStream.CanSeek); + exit(false); + END; + + [External] + [LineStart(219)] + PROCEDURE CanWrite@1000000004() : Boolean; + BEGIN + if not IsNull(DotNetCryptoStream) then + exit(DotNetCryptoStream.CanWrite); + exit(false); + END; + + [External] + [LineStart(224)] + PROCEDURE Length@1000000008() : Integer; + BEGIN + if not IsNull(DotNetCryptoStream) then + exit(DotNetCryptoStream.Length); + exit(0); + END; + + [External] + [LineStart(229)] + PROCEDURE Position@1000000007() : Integer; + BEGIN + if not IsNull(DotNetCryptoStream) then + exit(DotNetCryptoStream.Position); + exit(0); + END; + + [External] + [LineStart(234)] PROCEDURE Dispose@1000000006(); BEGIN DotNetCryptoStream.Dispose(); END; - [LineStart(253)] + [LineStart(237)] PROCEDURE GetCryptoStream@2(VAR DotNetCryptoStream2@1000000000 : DotNet "'mscorlib'.System.Security.Cryptography.CryptoStream"); BEGIN DotNetCryptoStream2 := DotNetCryptoStream; END; - [LineStart(256)] + [LineStart(240)] PROCEDURE SetCryptoStream@3(VAR DotNetCryptoStream2@1000000000 : DotNet "'mscorlib'.System.Security.Cryptography.CryptoStream"); BEGIN DotNetCryptoStream := DotNetCryptoStream2; diff --git a/BaseApp/COD50015.TXT b/BaseApp/COD50015.TXT index 775681a..c5596a7 100644 --- a/BaseApp/COD50015.TXT +++ b/BaseApp/COD50015.TXT @@ -18,62 +18,67 @@ OBJECT Codeunit 50015 DotNet_CipherMode DotNetCipherMode@1000000000 : DotNet "'mscorlib'.System.Security.Cryptography.CipherMode"; [External] - [LineStart(261)] - PROCEDURE CBC@1000000000() : Integer; + [LineStart(245)] + PROCEDURE CBC@1000000000(); VAR Mode@1000000000 : Integer; BEGIN - Mode := DotNetCipherMode.CBC; - exit(Mode); + DotNetCipherMode := DotNetCipherMode.CBC; END; [External] - [LineStart(265)] - PROCEDURE ECB@1000000001() : Integer; + [LineStart(248)] + PROCEDURE ECB@1000000001(); VAR Mode@1000000000 : Integer; BEGIN - Mode := DotNetCipherMode.ECB; - exit(Mode); + DotNetCipherMode := DotNetCipherMode.ECB; END; [External] - [LineStart(269)] - PROCEDURE OFB@1000000002() : Integer; + [LineStart(251)] + PROCEDURE OFB@1000000002(); VAR Mode@1000000000 : Integer; BEGIN - Mode := DotNetCipherMode.OFB; - exit(Mode); + DotNetCipherMode := DotNetCipherMode.OFB; END; [External] - [LineStart(273)] - PROCEDURE CFB@1000000003() : Integer; + [LineStart(254)] + PROCEDURE CFB@1000000003(); VAR Mode@1000000000 : Integer; BEGIN - Mode := DotNetCipherMode.CFB; - exit(Mode); + DotNetCipherMode := DotNetCipherMode.CFB; + END; + + [External] + [LineStart(257)] + PROCEDURE CTS@1000000004(); + VAR + Mode@1000000000 : Integer; + BEGIN + DotNetCipherMode := DotNetCipherMode.CTS; END; [External] - [LineStart(277)] - PROCEDURE CTS@1000000004() : Integer; + [LineStart(260)] + PROCEDURE Value@1000000005() : Integer; VAR Mode@1000000000 : Integer; BEGIN - Mode := DotNetCipherMode.CTS; + Mode := DotNetCipherMode; exit(Mode); END; - [LineStart(281)] + [LineStart(264)] PROCEDURE GetCipherMode@1000000006(VAR DotNetCipherMode2@1000000000 : DotNet "'mscorlib'.System.Security.Cryptography.CipherMode"); BEGIN DotNetCipherMode2 := DotNetCipherMode; END; - [LineStart(284)] + [LineStart(267)] PROCEDURE SetCipherMode@1000000007(VAR DotNetCipherMode2@1000000000 : DotNet "'mscorlib'.System.Security.Cryptography.CipherMode"); BEGIN DotNetCipherMode := DotNetCipherMode2; diff --git a/BaseApp/COD50016.TXT b/BaseApp/COD50016.TXT index d937244..bad27b8 100644 --- a/BaseApp/COD50016.TXT +++ b/BaseApp/COD50016.TXT @@ -18,62 +18,67 @@ OBJECT Codeunit 50016 DotNet_PaddingMode DotNetPaddingMode@1000000000 : DotNet "'mscorlib'.System.Security.Cryptography.PaddingMode"; [External] - [LineStart(289)] - PROCEDURE None@1000000000() : Integer; + [LineStart(272)] + PROCEDURE None@1000000000(); VAR Mode@1000000000 : Integer; BEGIN - Mode := DotNetPaddingMode.None; - exit(Mode); + DotNetPaddingMode := DotNetPaddingMode.None; END; [External] - [LineStart(293)] - PROCEDURE PKCS7@1000000001() : Integer; + [LineStart(275)] + PROCEDURE PKCS7@1000000001(); VAR Mode@1000000000 : Integer; BEGIN - Mode := DotNetPaddingMode.PKCS7; - exit(Mode); + DotNetPaddingMode := DotNetPaddingMode.PKCS7; END; [External] - [LineStart(297)] - PROCEDURE Zeros@1000000002() : Integer; + [LineStart(278)] + PROCEDURE Zeros@1000000002(); VAR Mode@1000000000 : Integer; BEGIN - Mode := DotNetPaddingMode.Zeros; - exit(Mode); + DotNetPaddingMode := DotNetPaddingMode.Zeros; END; [External] - [LineStart(301)] - PROCEDURE ANSIX923@1000000003() : Integer; + [LineStart(281)] + PROCEDURE ANSIX923@1000000003(); VAR Mode@1000000000 : Integer; BEGIN - Mode := DotNetPaddingMode.ANSIX923; - exit(Mode); + DotNetPaddingMode := DotNetPaddingMode.ANSIX923; END; [External] - [LineStart(305)] - PROCEDURE ISO10126@1000000004() : Integer; + [LineStart(284)] + PROCEDURE ISO10126@1000000004(); VAR Mode@1000000000 : Integer; BEGIN - Mode := DotNetPaddingMode.ISO10126; - exit(Mode); + DotNetPaddingMode := DotNetPaddingMode.ISO10126; END; - [LineStart(309)] + [External] + [LineStart(287)] + PROCEDURE Value@1000000007() : Integer; + VAR + PaddingMode@1000000000 : Integer; + BEGIN + PaddingMode := DotNetPaddingMode; + exit(PaddingMode); + END; + + [LineStart(291)] PROCEDURE GetPaddingMode@1000000005(VAR DotNetPaddingMode2@1000000000 : DotNet "'mscorlib'.System.Security.Cryptography.PaddingMode"); BEGIN DotNetPaddingMode2 := DotNetPaddingMode; END; - [LineStart(312)] + [LineStart(294)] PROCEDURE SetPaddingMode@1000000006(VAR DotNetPaddingMode2@1000000000 : DotNet "'mscorlib'.System.Security.Cryptography.PaddingMode"); BEGIN DotNetPaddingMode := DotNetPaddingMode2; diff --git a/BaseApp/COD50017.TXT b/BaseApp/COD50017.TXT new file mode 100644 index 0000000..88e1610 --- /dev/null +++ b/BaseApp/COD50017.TXT @@ -0,0 +1,54 @@ +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] + [LineStart(299)] + PROCEDURE Read@1000000000(); + VAR + Mode@1000000000 : Integer; + BEGIN + DotNetCryptoStreamMode := DotNetCryptoStreamMode.Read; + END; + + [External] + [LineStart(302)] + PROCEDURE Write@1000000001(); + VAR + Mode@1000000000 : Integer; + BEGIN + DotNetCryptoStreamMode := DotNetCryptoStreamMode.Write; + END; + + [LineStart(305)] + PROCEDURE GetCryptoStreamMode@1000000005(VAR DotNetCryptoStreamMode2@1000000000 : DotNet "'mscorlib'.System.Security.Cryptography.CryptoStreamMode"); + BEGIN + DotNetCryptoStreamMode2 := DotNetCryptoStreamMode; + END; + + [LineStart(308)] + 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 index 0d03394..8ed74e1 100644 --- a/BaseApp/COD50020.TXT +++ b/BaseApp/COD50020.TXT @@ -20,16 +20,14 @@ OBJECT Codeunit 50020 Symmetric Encryption Mgt KeySize@1000000001 : Integer; BlockSize@1000000000 : Integer; SymmetricAlgorithm@1000000003 : Text; - Mode@1000000002 : ',CBC,ECB,OFB,CFB,CTS'; - Padding@1000000005 : ',None,PKCS7,Zeros,ANSIX923,ISO10126'; + DotNetCipherMode@1000000002 : DotNet "'mscorlib'.System.Security.Cryptography.CipherMode"; + DotNetPaddingMode@1000000005 : DotNet "'mscorlib'.System.Security.Cryptography.PaddingMode"; DotNet_ArrayKey@1000000008 : Codeunit DotNet_Array; DotNet_ArrayIV@1000000007 : Codeunit DotNet_Array; E_NO_CIPHER@1000000004 : TextConst 'ENU=SymmetricAlgorithm - cipher not defined'; - E_INVALID_CIPHERMODE@1000000006 : TextConst 'ENU=Invalid Cipher mode'; - E_INVALID_PADDINGMODE@1000000009 : TextConst 'ENU=Invalid Padding mode'; [External] - [LineStart(319)] + [LineStart(315)] PROCEDURE SetCipher@1000000015(VAR CipherText@1000000000 : Text); VAR TempBlob@1000000001 : Record TempBlob; @@ -46,7 +44,7 @@ OBJECT Codeunit 50020 Symmetric Encryption Mgt END; [External] - [LineStart(330)] + [LineStart(326)] PROCEDURE SetCipherFromBlob@1000000014(VAR TempBlob@1000000000 : Record TempBlob); BEGIN @@ -54,7 +52,7 @@ OBJECT Codeunit 50020 Symmetric Encryption Mgt END; [External] - [LineStart(334)] + [LineStart(330)] PROCEDURE Base64ToPlainText@1000000053(Base64Text@1000000000 : Text) : Text; VAR DotNet_Encoding@1000000001 : Codeunit DotNet_Encoding; @@ -75,7 +73,7 @@ OBJECT Codeunit 50020 Symmetric Encryption Mgt END; [External] - [LineStart(346)] + [LineStart(342)] PROCEDURE SetAlgorithm@1000000023(Algorithm@1000000000 : Text); BEGIN @@ -83,7 +81,7 @@ OBJECT Codeunit 50020 Symmetric Encryption Mgt END; [External] - [LineStart(350)] + [LineStart(346)] PROCEDURE SetKeySize@1000000021(Size@1000000000 : Integer); BEGIN @@ -91,7 +89,7 @@ OBJECT Codeunit 50020 Symmetric Encryption Mgt END; [External] - [LineStart(354)] + [LineStart(350)] PROCEDURE SetBlockSize@1000000022(Size@1000000000 : Integer); BEGIN @@ -99,31 +97,21 @@ OBJECT Codeunit 50020 Symmetric Encryption Mgt END; [External] - [LineStart(358)] - PROCEDURE SetMode@1000000024(CipherMode@1000000000 : Integer); - VAR - DotNet_CipherMode@1000000001 : Codeunit DotNet_CipherMode; + [LineStart(354)] + PROCEDURE SetMode@1000000024(VAR DotNet_CipherMode@1000000000 : Codeunit DotNet_CipherMode); BEGIN - - if (CipherMode < DotNet_CipherMode.CBC) or (CipherMode > DotNet_CipherMode.CTS) then - Error(E_INVALID_CIPHERMODE); - Mode := CipherMode; + DotNet_CipherMode.GetCipherMode(DotNetCipherMode); END; [External] - [LineStart(364)] - PROCEDURE SetPadding@1000000000(PaddingMode@1000000000 : Integer); - VAR - DotNet_PaddingMode@1000000001 : Codeunit DotNet_PaddingMode; + [LineStart(357)] + PROCEDURE SetPadding@1000000000(VAR DotNet_PaddingMode@1000000000 : Codeunit DotNet_PaddingMode); BEGIN - - if (PaddingMode < DotNet_PaddingMode.None) or (PaddingMode > DotNet_PaddingMode.ISO10126) then - Error(E_INVALID_PADDINGMODE); - Padding := PaddingMode; + DotNet_PaddingMode.GetPaddingMode(DotNetPaddingMode); END; [External] - [LineStart(370)] + [LineStart(360)] PROCEDURE SetKey@1000000008(VAR DotNet_Array@1000000000 : Codeunit DotNet_Array); BEGIN @@ -131,7 +119,7 @@ OBJECT Codeunit 50020 Symmetric Encryption Mgt END; [External] - [LineStart(374)] + [LineStart(364)] PROCEDURE SetIV@1000000009(VAR DotNet_Array@1000000000 : Codeunit DotNet_Array); BEGIN @@ -139,7 +127,7 @@ OBJECT Codeunit 50020 Symmetric Encryption Mgt END; [External] - [LineStart(378)] + [LineStart(368)] PROCEDURE EncryptTextBase64@1000000001(UnEncryptedText@1000000000 : Text;VAR EncryptedTextBase64@1000000003 : Text) : Boolean; VAR Result@1000000002 : Boolean; @@ -152,7 +140,7 @@ OBJECT Codeunit 50020 Symmetric Encryption Mgt END; [External] - [LineStart(385)] + [LineStart(375)] PROCEDURE DecryptTextBase64@1000000002(EncryptedText@1000000000 : Text;VAR UnEncryptedText@1000000003 : Text) : Boolean; VAR Result@1000000002 : Boolean; @@ -165,7 +153,7 @@ OBJECT Codeunit 50020 Symmetric Encryption Mgt END; [External] - [LineStart(392)] + [LineStart(382)] PROCEDURE EncryptTempBlob@1000000006(VAR UnEncryptedTempBlob@1000000000 : Record TempBlob;VAR EncryptedTempBlob@1000000003 : Record TempBlob) : Boolean; VAR Result@1000000002 : Boolean; @@ -177,7 +165,7 @@ OBJECT Codeunit 50020 Symmetric Encryption Mgt END; [External] - [LineStart(398)] + [LineStart(388)] PROCEDURE DecryptTempBlob@1000000005(VAR EncryptedTempBlob@1000000000 : Record TempBlob;VAR DecryptedTempBlob@1000000003 : Record TempBlob) : Boolean; VAR Result@1000000002 : Boolean; @@ -189,7 +177,7 @@ OBJECT Codeunit 50020 Symmetric Encryption Mgt END; [External] - [LineStart(404)] + [LineStart(394)] PROCEDURE EncryptStream@1000000003(VAR UnEncryptedStream@1000000002 : InStream;VAR EncryptedStream@1000000000 : OutStream) : Boolean; VAR Result@1000000003 : Boolean; @@ -201,7 +189,7 @@ OBJECT Codeunit 50020 Symmetric Encryption Mgt END; [External] - [LineStart(410)] + [LineStart(400)] PROCEDURE DecryptStream@1000000004(VAR EncryptedStream@1000000001 : InStream;VAR UnEncryptedStream@1000000000 : OutStream) : Boolean; VAR Result@1000000003 : Boolean; @@ -214,7 +202,7 @@ OBJECT Codeunit 50020 Symmetric Encryption Mgt // Private Interface ====================================================================================== END; - [LineStart(418)] + [LineStart(408)] LOCAL PROCEDURE KeyLengthInBytes@1000000017() : Integer; VAR Size@1000000000 : Integer; @@ -226,7 +214,7 @@ OBJECT Codeunit 50020 Symmetric Encryption Mgt END; [TryFunction] - [LineStart(424)] + [LineStart(414)] LOCAL PROCEDURE TryEncryptTextBase64@1000000040(VAR UnEncryptedText@1000000012 : Text;VAR EncryptedTextBase64@1000000014 : Text); VAR OStream@1000000002 : OutStream; @@ -253,7 +241,7 @@ OBJECT Codeunit 50020 Symmetric Encryption Mgt END; [TryFunction] - [LineStart(443)] + [LineStart(433)] LOCAL PROCEDURE TryDecryptTextBase64@1000000039(VAR EncryptedTextBase64@1000000001 : Text;VAR DecryptedText@1000000000 : Text); VAR IStream@1000000008 : InStream; @@ -295,7 +283,7 @@ OBJECT Codeunit 50020 Symmetric Encryption Mgt END; [TryFunction] - [LineStart(473)] + [LineStart(463)] LOCAL PROCEDURE TryEncryptTempBlob@1000000012(VAR UnEncryptedTempBlob@1000000006 : Record TempBlob;VAR EncryptedTempBlob@1000000002 : Record TempBlob); VAR IStream@1000000001 : InStream; @@ -318,7 +306,7 @@ OBJECT Codeunit 50020 Symmetric Encryption Mgt END; [TryFunction] - [LineStart(489)] + [LineStart(479)] LOCAL PROCEDURE TryDecryptTempBlob@1000000007(VAR EncryptedTempBlob@1000000001 : Record TempBlob;VAR DecryptedTempBlob@1000000000 : Record TempBlob); VAR IStream@1000000008 : InStream; @@ -341,7 +329,7 @@ OBJECT Codeunit 50020 Symmetric Encryption Mgt END; [TryFunction] - [LineStart(505)] + [LineStart(495)] LOCAL PROCEDURE TryEncryptStream@1000000035(VAR UnEncryptedStream@1000000001 : InStream;VAR EncryptedStream@1000000000 : OutStream); VAR DotNetSymmetricAlgorithm@1000000021 : DotNet "'mscorlib'.System.Security.Cryptography.SymmetricAlgorithm"; @@ -407,7 +395,7 @@ OBJECT Codeunit 50020 Symmetric Encryption Mgt END; [TryFunction] - [LineStart(548)] + [LineStart(538)] LOCAL PROCEDURE TryDecryptStream@1000000036(VAR EncryptedStream@1000000001 : InStream;VAR DecryptedStream@1000000000 : OutStream); VAR DotNetSymmetricAlgorithm@1000000010 : DotNet "'mscorlib'.System.Security.Cryptography.SymmetricAlgorithm"; @@ -474,24 +462,30 @@ OBJECT Codeunit 50020 Symmetric Encryption Mgt END; [TryFunction] - [LineStart(592)] + [LineStart(582)] LOCAL PROCEDURE TryCreateSymmetricAlgorithm@1000000025(VAR DotNet_SymmetricAlgorithm@1000000005 : Codeunit DotNet_SymmetricAlgorithm); + VAR + DotNet_CipherMode@1000000000 : Codeunit DotNet_CipherMode; + DotNet_PaddingMode@1000000001 : Codeunit DotNet_PaddingMode; 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); - if Mode > 0 then DotNet_SymmetricAlgorithm.SetMode(Mode); + DotNet_SymmetricAlgorithm.SetMode(DotNet_CipherMode); if BlockSize > 0 then DotNet_SymmetricAlgorithm.SetBlockSize(BlockSize); - if Padding > 0 then DotNet_SymmetricAlgorithm.SetPadding(Padding); + 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] - [LineStart(605)] + [LineStart(598)] LOCAL PROCEDURE TrySetCipher@1000000016(VAR TempBlob@1000000000 : Record TempBlob); VAR IStream@1000000001 : InStream; diff --git a/Test/COD51010.TXT b/Test/COD51010.TXT index a129735..0bacd67 100644 --- a/Test/COD51010.TXT +++ b/Test/COD51010.TXT @@ -17,118 +17,150 @@ OBJECT Codeunit 51010 Test_DotNet_SymmetricAlgorithm CODE { VAR - Assert@1001 : Codeunit 130000; + Assert@1001 : Codeunit Assert; IsInitialized@1000000002 : Boolean; Algorithm@1000000000 : 'Aes,DES,RC2,Rijndael,TripleDES'; Mode@1000000003 : ',CBC,ECB,OFB,CFB,CTS'; Padding@1000000001 : ',None,PKCS7,Zeros,ANSIX923,ISO10126'; - LOCAL PROCEDURE Initialize@1000000005(); + [Test] + [LineStart(619)] + PROCEDURE TestSymmetricAlgorithmCreateAes@1000000006(); + VAR + DotNet_SymmetricAlgorithm@1000000000 : Codeunit DotNet_SymmetricAlgorithm; + DotNetSymmetricAlgorithm@1000000001 : DotNet "'mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089'.System.Security.Cryptography.SymmetricAlgorithm"; BEGIN - IF IsInitialized THEN - EXIT; - IsInitialized := TRUE; + SymmetricAlgorithmCreateAes(); END; [Test] - PROCEDURE TestSymmetricAlgorithmCreate@1000000006(); + [LineStart(622)] + PROCEDURE TestSymmetricAlgorithmCreateDES@1000000014(); VAR - DotNet_SymmetricAlgorithm@1000000000 : Codeunit 50010; + DotNet_SymmetricAlgorithm@1000000000 : Codeunit DotNet_SymmetricAlgorithm; DotNetSymmetricAlgorithm@1000000001 : DotNet "'mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089'.System.Security.Cryptography.SymmetricAlgorithm"; BEGIN - Initialize(); - SymmetricAlgorithmCreateAes(); SymmetricAlgorithmCreateDES(); + END; + + [Test] + [LineStart(625)] + PROCEDURE TestSymmetricAlgorithmCreateRC2@1000000015(); + VAR + DotNet_SymmetricAlgorithm@1000000000 : Codeunit DotNet_SymmetricAlgorithm; + DotNetSymmetricAlgorithm@1000000001 : DotNet "'mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089'.System.Security.Cryptography.SymmetricAlgorithm"; + BEGIN SymmetricAlgorithmCreateRC2(); + END; + + [Test] + [LineStart(628)] + PROCEDURE TestSymmetricAlgorithmCreateRijndael@1000000016(); + VAR + DotNet_SymmetricAlgorithm@1000000000 : Codeunit DotNet_SymmetricAlgorithm; + DotNetSymmetricAlgorithm@1000000001 : DotNet "'mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089'.System.Security.Cryptography.SymmetricAlgorithm"; + BEGIN SymmetricAlgorithmCreateRijndael(); + END; + + [Test] + [LineStart(631)] + PROCEDURE TestSymmetricAlgorithmCreateTripleDES@1000000017(); + VAR + DotNet_SymmetricAlgorithm@1000000000 : Codeunit DotNet_SymmetricAlgorithm; + DotNetSymmetricAlgorithm@1000000001 : DotNet "'mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089'.System.Security.Cryptography.SymmetricAlgorithm"; + BEGIN SymmetricAlgorithmCreateTripleDES(); END; [Test] + [LineStart(634)] PROCEDURE TestSetGetMode@1000000008(); VAR - DotNet_SymmetricAlgorithm@1000000001 : Codeunit 50010; - CipherMode@1000000000 : ',CBC,ECB,OFB,CFB,CTS'; + DotNet_SymmetricAlgorithm@1000000001 : Codeunit DotNet_SymmetricAlgorithm; + DotNet_CipherMode@1000000002 : Codeunit DotNet_CipherMode; + DotNet_CipherMode2@1000000003 : Codeunit DotNet_CipherMode; BEGIN - Initialize(); - DotNet_SymmetricAlgorithm.Create(Algorithm::Aes); - DotNet_SymmetricAlgorithm.SetMode(Mode::CBC); - DotNet_SymmetricAlgorithm.GetMode(CipherMode); - Assert.AreEqual(Mode::CBC, CipherMode, 'SymmetricAlgorithm Get/Set Mode failed'); + 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] + [LineStart(641)] PROCEDURE TestSetGetPadding@1000000007(); VAR - DotNet_SymmetricAlgorithm@1000000000 : Codeunit 50010; - PaddingMode@1000000001 : ',None,PKCS7,Zeros,ANSIX923,ISO10126'; + DotNet_SymmetricAlgorithm@1000000000 : Codeunit DotNet_SymmetricAlgorithm; + DotNet_PaddingMode@1000000001 : Codeunit DotNet_PaddingMode; + DotNet_PaddingMode2@1000000002 : Codeunit DotNet_PaddingMode; BEGIN - Initialize(); - DotNet_SymmetricAlgorithm.Create(Algorithm::Aes); - DotNet_SymmetricAlgorithm.SetMode(Padding::Zeros); - DotNet_SymmetricAlgorithm.GetMode(PaddingMode); - Assert.AreEqual(Padding::Zeros, PaddingMode, 'SymmetricAlgorithm Get/Set Padding failed'); + 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] + [LineStart(648)] PROCEDURE TestSetGetBlockSize@1000000012(); VAR - DotNet_SymmetricAlgorithm@1000000000 : Codeunit 50010; + DotNet_SymmetricAlgorithm@1000000000 : Codeunit DotNet_SymmetricAlgorithm; BlockSize@1000000001 : Integer; BEGIN - Initialize(); - DotNet_SymmetricAlgorithm.Create(Algorithm::Aes); + DotNet_SymmetricAlgorithm.Create('Aes'); DotNet_SymmetricAlgorithm.SetBlockSize(128); - DotNet_SymmetricAlgorithm.GetBlockSize(BlockSize); + BlockSize := DotNet_SymmetricAlgorithm.GetBlockSize(); Assert.AreEqual(128, BlockSize, 'SymmetricAlgorithm Get/Set Blocksize failed'); END; [Test] + [LineStart(654)] PROCEDURE TestSetGetKeySize@1000000009(); VAR - DotNet_SymmetricAlgorithm@1000000000 : Codeunit 50010; + DotNet_SymmetricAlgorithm@1000000000 : Codeunit DotNet_SymmetricAlgorithm; KeySize@1000000001 : Integer; BEGIN - Initialize(); - DotNet_SymmetricAlgorithm.Create(Algorithm::Aes); + DotNet_SymmetricAlgorithm.Create('Aes'); DotNet_SymmetricAlgorithm.SetKeySize(256); - DotNet_SymmetricAlgorithm.GetKeySize(KeySize); + KeySize := DotNet_SymmetricAlgorithm.GetKeySize(); Assert.AreEqual(256, KeySize, 'SymmetricAlgorithm Get/Set KeySize failed'); END; [Test] + [LineStart(660)] PROCEDURE TestSetGetFeedbackSize@1000000013(); VAR - DotNet_SymmetricAlgorithm@1000000000 : Codeunit 50010; + DotNet_SymmetricAlgorithm@1000000000 : Codeunit DotNet_SymmetricAlgorithm; FeedbackSize@1000000001 : Integer; BEGIN - Initialize(); - DotNet_SymmetricAlgorithm.Create(Algorithm::Aes); + DotNet_SymmetricAlgorithm.Create('Aes'); DotNet_SymmetricAlgorithm.SetBlockSize(128); DotNet_SymmetricAlgorithm.SetFeedbackSize(64); - DotNet_SymmetricAlgorithm.GetFeedbackSize(FeedbackSize); + FeedbackSize := DotNet_SymmetricAlgorithm.GetFeedbackSize(); Assert.AreEqual(64, FeedbackSize, 'SymmetricAlgorithm Get/Set FeedbackSize failed'); END; [Test] + [LineStart(667)] PROCEDURE TestSetGetKey@1000000010(); VAR - DotNet_SymmetricAlgorithm@1000000000 : Codeunit 50010; - DotNet_Array@1000000001 : Codeunit 3000; - DotNet_ArrayKey@1000000002 : Codeunit 3000; + DotNet_SymmetricAlgorithm@1000000000 : Codeunit DotNet_SymmetricAlgorithm; + DotNet_Array@1000000001 : Codeunit DotNet_Array; + DotNet_ArrayKey@1000000002 : Codeunit DotNet_Array; Index@1000000003 : Integer; BEGIN - Initialize(); - DotNet_Array.ByteArray(32); - FOR Index := 0 TO DotNet_Array.Length-1 DO + for Index := 0 to DotNet_Array.Length-1 do DotNet_Array.SetByteValue(Index, Index); - DotNet_SymmetricAlgorithm.Create(Algorithm::Aes); + 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 + for Index := 0 to DotNet_Array.Length-1 do Assert.AreEqual( DotNet_Array.GetValueAsInteger(Index), DotNet_ArrayKey.GetValueAsInteger(Index), @@ -136,78 +168,82 @@ OBJECT Codeunit 51010 Test_DotNet_SymmetricAlgorithm END; [Test] + [LineStart(682)] PROCEDURE TestSetGetIV@1000000011(); VAR - DotNet_SymmetricAlgorithm@1000000000 : Codeunit 50010; - DotNet_Array@1000000003 : Codeunit 3000; - DotNet_ArrayIV@1000000002 : Codeunit 3000; + DotNet_SymmetricAlgorithm@1000000000 : Codeunit DotNet_SymmetricAlgorithm; + DotNet_Array@1000000003 : Codeunit DotNet_Array; + DotNet_ArrayIV@1000000002 : Codeunit DotNet_Array; Index@1000000001 : Integer; BEGIN - Initialize(); - DotNet_Array.ByteArray(16); - FOR Index := 0 TO DotNet_Array.Length-1 DO + for Index := 0 to DotNet_Array.Length-1 do DotNet_Array.SetByteValue(Index, Index); - DotNet_SymmetricAlgorithm.Create(Algorithm::Aes); + 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 + 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; + [LineStart(697)] PROCEDURE SymmetricAlgorithmCreateAes@1000000000(); VAR - DotNet_SymmetricAlgorithm@1000000000 : Codeunit 50010; + DotNet_SymmetricAlgorithm@1000000000 : Codeunit DotNet_SymmetricAlgorithm; DotNetSymmetricAlgorithm@1000000001 : DotNet "'mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089'.System.Security.Cryptography.SymmetricAlgorithm"; BEGIN - DotNet_SymmetricAlgorithm.Create(Algorithm::Aes); + DotNet_SymmetricAlgorithm.Create('Aes'); DotNet_SymmetricAlgorithm.GetSymmetricAlgorithm(DotNetSymmetricAlgorithm); - Assert.IsFalse(ISNULL(DotNetSymmetricAlgorithm), 'SymmetricAlgorithm Create AES failed'); + Assert.IsFalse(IsNull(DotNetSymmetricAlgorithm), 'SymmetricAlgorithm Create AES failed'); END; + [LineStart(702)] PROCEDURE SymmetricAlgorithmCreateDES@1000000003(); VAR - DotNet_SymmetricAlgorithm@1000000000 : Codeunit 50010; + DotNet_SymmetricAlgorithm@1000000000 : Codeunit DotNet_SymmetricAlgorithm; DotNetSymmetricAlgorithm@1000000001 : DotNet "'mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089'.System.Security.Cryptography.SymmetricAlgorithm"; BEGIN - DotNet_SymmetricAlgorithm.Create(Algorithm::DES); + DotNet_SymmetricAlgorithm.Create('DES'); DotNet_SymmetricAlgorithm.GetSymmetricAlgorithm(DotNetSymmetricAlgorithm); - Assert.IsFalse(ISNULL(DotNetSymmetricAlgorithm), 'SymmetricAlgorithm Create DES failed'); + Assert.IsFalse(IsNull(DotNetSymmetricAlgorithm), 'SymmetricAlgorithm Create DES failed'); END; + [LineStart(707)] PROCEDURE SymmetricAlgorithmCreateRC2@1000000001(); VAR - DotNet_SymmetricAlgorithm@1000000000 : Codeunit 50010; + DotNet_SymmetricAlgorithm@1000000000 : Codeunit DotNet_SymmetricAlgorithm; DotNetSymmetricAlgorithm@1000000001 : DotNet "'mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089'.System.Security.Cryptography.SymmetricAlgorithm"; BEGIN - DotNet_SymmetricAlgorithm.Create(Algorithm::RC2); + DotNet_SymmetricAlgorithm.Create('RC2'); DotNet_SymmetricAlgorithm.GetSymmetricAlgorithm(DotNetSymmetricAlgorithm); - Assert.IsFalse(ISNULL(DotNetSymmetricAlgorithm), 'SymmetricAlgorithm Create RC2 failed'); + Assert.IsFalse(IsNull(DotNetSymmetricAlgorithm), 'SymmetricAlgorithm Create RC2 failed'); END; + [LineStart(712)] PROCEDURE SymmetricAlgorithmCreateRijndael@1000000002(); VAR - DotNet_SymmetricAlgorithm@1000000000 : Codeunit 50010; + DotNet_SymmetricAlgorithm@1000000000 : Codeunit DotNet_SymmetricAlgorithm; DotNetSymmetricAlgorithm@1000000001 : DotNet "'mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089'.System.Security.Cryptography.SymmetricAlgorithm"; BEGIN - DotNet_SymmetricAlgorithm.Create(Algorithm::Rijndael); + DotNet_SymmetricAlgorithm.Create('Rijndael'); DotNet_SymmetricAlgorithm.GetSymmetricAlgorithm(DotNetSymmetricAlgorithm); - Assert.IsFalse(ISNULL(DotNetSymmetricAlgorithm), 'SymmetricAlgorithm Create Rijndael failed'); + Assert.IsFalse(IsNull(DotNetSymmetricAlgorithm), 'SymmetricAlgorithm Create Rijndael failed'); END; + [LineStart(717)] PROCEDURE SymmetricAlgorithmCreateTripleDES@1000000004(); VAR - DotNet_SymmetricAlgorithm@1000000000 : Codeunit 50010; + DotNet_SymmetricAlgorithm@1000000000 : Codeunit DotNet_SymmetricAlgorithm; DotNetSymmetricAlgorithm@1000000001 : DotNet "'mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089'.System.Security.Cryptography.SymmetricAlgorithm"; BEGIN - DotNet_SymmetricAlgorithm.Create(Algorithm::TripleDES); + DotNet_SymmetricAlgorithm.Create('TripleDES'); DotNet_SymmetricAlgorithm.GetSymmetricAlgorithm(DotNetSymmetricAlgorithm); - Assert.IsFalse(ISNULL(DotNetSymmetricAlgorithm), 'SymmetricAlgorithm Create TripleDES failed'); + Assert.IsFalse(IsNull(DotNetSymmetricAlgorithm), 'SymmetricAlgorithm Create TripleDES failed'); END; BEGIN diff --git a/Test/COD51012.TXT b/Test/COD51012.TXT index cf5b99f..605d85a 100644 --- a/Test/COD51012.TXT +++ b/Test/COD51012.TXT @@ -17,96 +17,88 @@ OBJECT Codeunit 51012 Test_DotNet_HashAlgorithm CODE { VAR - Assert@1001 : Codeunit 130000; - DotNet_HashAlgorithm@1002 : Codeunit 3025; - DotNet_Array@1000000001 : Codeunit 3000; - HashAlgorithm@1000000000 : 'SHA1,MD5,SHA256,SHA384,SHA512'; - IsInitialized@1000000002 : Boolean; - - LOCAL PROCEDURE Initialize@1000000005(); - BEGIN - IF IsInitialized THEN - EXIT; - IsInitialized := TRUE; - END; + Assert@1001 : Codeunit Assert; + DotNet_HashAlgorithm@1002 : Codeunit DotNet_StreamWriter; + DotNet_Array@1000000001 : Codeunit DotNet_Array; [Test] + [LineStart(724)] PROCEDURE TestGenerateFromText@1(); VAR SampleText@1000000000 : Text; ExpectedText@1000000003 : Text; HashText@1000000001 : Text; BEGIN - Initialize(); SampleText := 'Lorem ipsum dolor sit amet, consectetur adipiscing elit'; // SHA1 ExpectedText := '4045ed3c779e3b27760e4da357279508a8452dcb'; - HashText := GenerateFromText(HashAlgorithm::SHA1, SampleText); - Assert.AreEqual(ExpectedText, LOWERCASE(HashText), 'SHA1 Hashes differ, failed'); + HashText := GenerateFromText('SHA1', SampleText); + Assert.AreEqual(ExpectedText, LowerCase(HashText), 'SHA1 Hashes differ, failed'); // MD5 ExpectedText := 'fc10a08df7fafa3871166646609e1c95'; - HashText := GenerateFromText(HashAlgorithm::MD5, SampleText); - Assert.AreEqual(ExpectedText, LOWERCASE(HashText), 'MD5 Hashes differ, failed'); + HashText := GenerateFromText('MD5', SampleText); + Assert.AreEqual(ExpectedText, LowerCase(HashText), 'MD5 Hashes differ, failed'); // SHA256 ExpectedText := '07fe4d4a25718241af145a93f890eb5469052e251d199d173bd3bd50c3bb4da2'; - HashText := GenerateFromText(HashAlgorithm::SHA256, SampleText); - Assert.AreEqual(ExpectedText, LOWERCASE(HashText), 'SHA256 Hashes differ, failed'); + HashText := GenerateFromText('SHA256', SampleText); + Assert.AreEqual(ExpectedText, LowerCase(HashText), 'SHA256 Hashes differ, failed'); // SHA384 ExpectedText := '845524c97cf0606df6ce8a2e5a7e35701a9ed12685a366eabef599648dd8ba33c1e176e96efe51320a40a6b65c18c4cf'; - HashText := GenerateFromText(HashAlgorithm::SHA384, SampleText); - Assert.AreEqual(ExpectedText, LOWERCASE(HashText), 'SHA384 Hashes differ, failed'); + HashText := GenerateFromText('SHA384', SampleText); + Assert.AreEqual(ExpectedText, LowerCase(HashText), 'SHA384 Hashes differ, failed'); // SHA512 ExpectedText := 'd3b3d69ccc163089f91d42ebef0f01dd70ec40deb76a9da5ba63ef5b39601b41a34b04f8236ce9e59a150241716a5e2da9f1bdcc2734d4d7fcd8e69df36022f0'; - HashText := GenerateFromText(HashAlgorithm::SHA512, SampleText); - Assert.AreEqual(ExpectedText, LOWERCASE(HashText), 'SHA512 Hashes differ, failed'); + HashText := GenerateFromText('SHA512', SampleText); + Assert.AreEqual(ExpectedText, LowerCase(HashText), 'SHA512 Hashes differ, failed'); END; [Test] + [LineStart(748)] PROCEDURE TestGenerateFromStream@1000000001(); VAR SampleText@1000000002 : Text; ExpectedText@1000000001 : Text; HashText@1000000000 : Text; IStream@1000000003 : InStream; - TempBlob@1000000004 : TEMPORARY Record 99008535; + TempBlob@1000000004 : TEMPORARY Record TempBlob; BEGIN - Initialize(); SampleText := 'Lorem ipsum dolor sit amet, consectetur adipiscing elit'; - CLEAR(TempBlob.Blob); + Clear(TempBlob.Blob); TempBlob.WriteAsText(SampleText, TEXTENCODING::UTF8); // SHA1 ExpectedText := '4045ed3c779e3b27760e4da357279508a8452dcb'; - TempBlob.Blob.CREATEINSTREAM(IStream); - HashText := GenerateFromStream(HashAlgorithm::SHA1, IStream); - Assert.AreEqual(ExpectedText, LOWERCASE(HashText), 'SHA1 Hashes differ, failed'); + 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(HashAlgorithm::MD5, IStream); - Assert.AreEqual(ExpectedText, LOWERCASE(HashText), 'MD5 Hashes differ, failed'); + 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(HashAlgorithm::SHA256, IStream); - Assert.AreEqual(ExpectedText, LOWERCASE(HashText), 'SHA256 Hashes differ, failed'); + 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(HashAlgorithm::SHA384, IStream); - Assert.AreEqual(ExpectedText, LOWERCASE(HashText), 'SHA384 Hashes differ, failed'); + 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(HashAlgorithm::SHA512, IStream); - Assert.AreEqual(ExpectedText, LOWERCASE(HashText), 'SHA512 Hashes differ, failed'); + TempBlob.Blob.CreateInStream(IStream); + HashText := GenerateFromStream('SHA512', IStream); + Assert.AreEqual(ExpectedText, LowerCase(HashText), 'SHA512 Hashes differ, failed'); END; - LOCAL PROCEDURE GenerateFromText@1000000002(HashMode@1000000000 : 'SHA1,MD5,SHA256,SHA384,SHA512';TextToHash@1000000003 : Text) : Text; + [LineStart(780)] + LOCAL PROCEDURE GenerateFromText@1000000002(HashMode@1000000000 : Text;TextToHash@1000000003 : Text) : Text; VAR - DotNet_HashAlgorithm@1000000002 : Codeunit 50012; + DotNet_HashAlgorithm@1000000002 : Codeunit DotNet_HashAlgorithm; DotNetBitConverter@1000000004 : DotNet "'mscorlib'.System.BitConverter"; DotNetArray@1000000005 : DotNet "'mscorlib'.System.Array"; DotNetString@1000000001 : DotNet "'mscorlib'.System.String"; @@ -115,12 +107,13 @@ OBJECT Codeunit 51012 Test_DotNet_HashAlgorithm DotNet_HashAlgorithm.ComputeHashFromText(TextToHash, DotNet_Array); DotNet_Array.GetArray(DotNetArray); DotNetString := DotNetBitConverter.ToString(DotNetArray); - EXIT(DotNetString.Replace('-','')); + exit(DotNetString.Replace('-','')); END; - LOCAL PROCEDURE GenerateFromStream@1000000003(HashMode@1000000001 : 'SHA1,MD5,SHA256,SHA384,SHA512';InputStream@1000000000 : InStream) : Text; + [LineStart(787)] + LOCAL PROCEDURE GenerateFromStream@1000000003(HashMode@1000000001 : Text;InputStream@1000000000 : InStream) : Text; VAR - DotNet_HashAlgorithm@1000000003 : Codeunit 50012; + DotNet_HashAlgorithm@1000000003 : Codeunit DotNet_HashAlgorithm; DotNetBitConverter@1000000004 : DotNet "'mscorlib'.System.BitConverter"; DotNetArray@1000000002 : DotNet "'mscorlib'.System.Array"; DotNetString@1000000005 : DotNet "'mscorlib'.System.String"; @@ -129,7 +122,7 @@ OBJECT Codeunit 51012 Test_DotNet_HashAlgorithm DotNet_HashAlgorithm.ComputeHashFromInStream(InputStream, DotNet_Array); DotNet_Array.GetArray(DotNetArray); DotNetString := DotNetBitConverter.ToString(DotNetArray); - EXIT(DotNetString.Replace('-','')); + exit(DotNetString.Replace('-','')); END; BEGIN diff --git a/Test/COD51013.TXT b/Test/COD51013.TXT index d8dc289..33078fb 100644 --- a/Test/COD51013.TXT +++ b/Test/COD51013.TXT @@ -17,21 +17,14 @@ OBJECT Codeunit 51013 Test_DotNet_ICryptoTransform CODE { VAR - Assert@1001 : Codeunit 130000; - IsInitialized@1000000002 : Boolean; - - LOCAL PROCEDURE Initialize@1000000005(); - BEGIN - IF IsInitialized THEN - EXIT; - IsInitialized := TRUE; - END; + Assert@1001 : Codeunit Assert; [Test] + [LineStart(796)] PROCEDURE TestGetSet@1000000000(); VAR - DotNet_SymmetricAlgorithm@1000000001 : Codeunit 50010; - DotNet_ICryptoTransform@1000000000 : Codeunit 50013; + DotNet_SymmetricAlgorithm@1000000001 : Codeunit DotNet_SymmetricAlgorithm; + DotNet_ICryptoTransform@1000000000 : Codeunit DotNet_ICryptoTransform; DotNetSymmetricAlgorithm@1000000003 : DotNet "'mscorlib'.System.Security.Cryptography.SymmetricAlgorithm"; DotNetICryptoTransform@1000000002 : DotNet "'mscorlib'.System.Security.Cryptography.ICryptoTransform"; DotNetICryptoTransform2@1000000004 : DotNet "'mscorlib'.System.Security.Cryptography.ICryptoTransform"; @@ -39,7 +32,7 @@ OBJECT Codeunit 51013 Test_DotNet_ICryptoTransform BEGIN // [WHEN] AES Symmetric Algorithm (with default settings) is created - DotNet_SymmetricAlgorithm.Create(Algorithm::Aes); + DotNet_SymmetricAlgorithm.Create('Aes'); DotNet_SymmetricAlgorithm.GetSymmetricAlgorithm(DotNetSymmetricAlgorithm); // [WHEN] Encryptor transform is created DotNetICryptoTransform := DotNetSymmetricAlgorithm.CreateEncryptor(); @@ -48,7 +41,7 @@ OBJECT Codeunit 51013 Test_DotNet_ICryptoTransform // [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'); + Assert.IsFalse(IsNull(DotNetICryptoTransform2), 'ICryptoTransform Get/Set failed'); END; BEGIN diff --git a/Test/COD51014.TXT b/Test/COD51014.TXT index ccdfd7e..c581ef2 100644 --- a/Test/COD51014.TXT +++ b/Test/COD51014.TXT @@ -17,86 +17,66 @@ OBJECT Codeunit 51014 Test_DotNet_CryptoStream CODE { VAR - Assert@1001 : Codeunit 130000; - IsInitialized@1000000002 : Boolean; - - LOCAL PROCEDURE Initialize@1000000005(); - BEGIN - IF IsInitialized THEN - EXIT; - IsInitialized := TRUE; - END; + Assert@1001 : Codeunit Assert; [Test] + [LineStart(812)] PROCEDURE TestCryptoOutStream@1000000000(); VAR - DotNet_SymmetricAlgorithm@1000000001 : Codeunit 50010; - DotNet_ICryptoTransform@1000000000 : Codeunit 50013; - DotNet_CryptoStream@1000000005 : Codeunit 50014; - DotNetSymmetricAlgorithm@1000000003 : DotNet "'mscorlib'.System.Security.Cryptography.SymmetricAlgorithm"; - DotNetICryptoTransform@1000000002 : DotNet "'mscorlib'.System.Security.Cryptography.ICryptoTransform"; - DotNetCryptoStream@1000000004 : DotNet "'mscorlib'.System.Security.Cryptography.CryptoStream"; - Algorithm@1000000006 : 'Aes,DES,RC2,Rijndael,TripleDES'; - TempBlob@1000000007 : TEMPORARY Record 99008535; + DotNet_SymmetricAlgorithm@1000000001 : Codeunit DotNet_SymmetricAlgorithm; + DotNet_ICryptoTransform@1000000000 : Codeunit DotNet_ICryptoTransform; + DotNet_CryptoStream@1000000005 : Codeunit DotNet_CryptoStream; + TempBlob@1000000007 : TEMPORARY Record TempBlob; OStream@1000000008 : OutStream; BEGIN // [WHEN] OutStream is initialized - CLEAR(TempBlob.Blob); - TempBlob.Blob.CREATEOUTSTREAM(OStream); + Clear(TempBlob.Blob); + TempBlob.Blob.CreateOutStream(OStream); // [WHEN] AES Symmetric Algorithm (with default settings) is created - DotNet_SymmetricAlgorithm.Create(Algorithm::Aes); - DotNet_SymmetricAlgorithm.GetSymmetricAlgorithm(DotNetSymmetricAlgorithm); + DotNet_SymmetricAlgorithm.Create('Aes'); // [WHEN] Encryptor transform is created - DotNetICryptoTransform := DotNetSymmetricAlgorithm.CreateEncryptor(); - DotNet_ICryptoTransform.SetICryptoTransform(DotNetICryptoTransform); + DotNet_SymmetricAlgorithm.CreateEncryptor(DotNet_ICryptoTransform); // [WHEN] Encrypting crypto outstream is created DotNet_CryptoStream.CryptoOutStream(OStream, DotNet_ICryptoTransform); - DotNet_CryptoStream.GetCryptoStream(DotNetCryptoStream); // [THEN] Encrypting crypto outstream is not NULL - Assert.IsFalse(ISNULL(DotNetCryptoStream), 'CryptoStream CryptoOutStream failed'); + Assert.IsTrue(DotNet_CryptoStream.CanWrite, 'CryptoStream CryptoOutStream failed'); END; [Test] + [LineStart(825)] PROCEDURE TestCryptoInStream@1000000001(); VAR - DotNet_SymmetricAlgorithm@1000000001 : Codeunit 50010; - DotNet_ICryptoTransform@1000000000 : Codeunit 50013; - DotNet_CryptoStream@1000000005 : Codeunit 50014; - DotNet_Array@1000000010 : Codeunit 3000; - DotNetSymmetricAlgorithm@1000000003 : DotNet "'mscorlib'.System.Security.Cryptography.SymmetricAlgorithm"; - DotNetICryptoTransform@1000000002 : DotNet "'mscorlib'.System.Security.Cryptography.ICryptoTransform"; - DotNetCryptoStream@1000000007 : DotNet "'mscorlib'.System.Security.Cryptography.CryptoStream"; - Algorithm@1000000008 : 'Aes,DES,RC2,Rijndael,TripleDES'; - TempBlob@1000000004 : TEMPORARY Record 99008535; + DotNet_SymmetricAlgorithm@1000000001 : Codeunit DotNet_SymmetricAlgorithm; + DotNet_ICryptoTransform@1000000000 : Codeunit DotNet_ICryptoTransform; + DotNet_CryptoStream@1000000005 : Codeunit DotNet_CryptoStream; + DotNet_Array@1000000010 : Codeunit DotNet_Array; + TempBlob@1000000004 : TEMPORARY Record TempBlob; IStream@1000000006 : InStream; Index@1000000009 : Integer; BEGIN // [WHEN] InStream is initialized - CLEAR(TempBlob.Blob); + Clear(TempBlob.Blob); TempBlob.WriteAsText('Lorem ipsum dolor', TEXTENCODING::UTF8); - TempBlob.Blob.CREATEINSTREAM(IStream); + TempBlob.Blob.CreateInStream(IStream); // [WHEN] AES Symmetric Algorithm (with 256 keysize, 128 blocksize) is created) - DotNet_SymmetricAlgorithm.Create(Algorithm::Aes); + 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 + 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 + for Index := 0 to DotNet_Array.Length-1 do DotNet_Array.SetByteValue(Index, Index); DotNet_SymmetricAlgorithm.SetIV(DotNet_Array); - DotNet_SymmetricAlgorithm.GetSymmetricAlgorithm(DotNetSymmetricAlgorithm); // [WHEN] Decryptor transform is created - DotNetICryptoTransform := DotNetSymmetricAlgorithm.CreateDecryptor(); - DotNet_ICryptoTransform.SetICryptoTransform(DotNetICryptoTransform); + DotNet_SymmetricAlgorithm.CreateDecryptor(DotNet_ICryptoTransform); // [WHEN] Decrypting crypto instream is created DotNet_CryptoStream.CryptoInStream(IStream, DotNet_ICryptoTransform); - DotNet_CryptoStream.GetCryptoStream(DotNetCryptoStream); // [THEN] Decrypting crypto outstream is not NULL - Assert.IsFalse(ISNULL(DotNetCryptoStream), 'CryptoStream CryptoInStream failed'); + Assert.IsTrue(DotNet_CryptoStream.CanWrite, 'CryptoStream CryptoInStream failed'); END; BEGIN diff --git a/Test/COD51020.TXT b/Test/COD51020.TXT index 1b355d5..ab7fd96 100644 --- a/Test/COD51020.TXT +++ b/Test/COD51020.TXT @@ -10,57 +10,46 @@ OBJECT Codeunit 51020 Test_Symmetric_Encryption_Mgt { Subtype=Test; OnRun=BEGIN - IsInitialized := FALSE; END; } CODE { VAR - Algorithm@1000000011 : 'Aes,DES,RC2,Rijndael,TripleDES'; - Mode@1000000003 : ',CBC,ECB,OFB,CFB,CTS'; - Padding@1000000002 : ',None,PKCS7,Zeros,ANSIX923,ISO10126'; - Assert@1000000005 : Codeunit 130000; - LibraryUtility@1000000001 : Codeunit 131000; - LibraryRandom@1000000000 : Codeunit 130440; - IsInitialized@1000000006 : Boolean; + Assert@1000000005 : Codeunit Assert; + LibraryUtility@1000000001 : Codeunit "Library - Utility"; + LibraryRandom@1000000000 : Codeunit "Library - Random"; 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 Initialize@1000000000(); - BEGIN - IF IsInitialized THEN - EXIT; - - IsInitialized := TRUE; - END; - + [LineStart(852)] 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); + 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); + [LineStart(855)] + LOCAL PROCEDURE EncryptDecryptText@1000000007(VAR SymmetricEncryption@1000000003 : Codeunit "Symmetric Encryption Mgt";VAR TextClear@1000000006 : Text;VAR TextEncrypted@1000000007 : Text;VAR TextDecrypted@1000000008 : Text); BEGIN SymmetricEncryption.EncryptTextBase64(TextClear, TextEncrypted); SymmetricEncryption.DecryptTextBase64(TextEncrypted, TextDecrypted); END; [Test] + [LineStart(859)] PROCEDURE AES_256_CBC_PKCS7_EncryptDecrypt@1000000004(); VAR - SymmetricEncryption@1000000003 : Codeunit 50020; + SymmetricEncryption@1000000003 : Codeunit "Symmetric Encryption Mgt"; TextCipher@1000000004 : Text; TextToEncrypt@1000000002 : Text; TextEncrypted@1000000001 : Text; TextDecrypted@1000000000 : Text; BEGIN - Initialize(); TextCipher := LibraryUtility.GenerateRandomText(LibraryRandom.RandIntInRange(1,64)); TextToEncrypt := LibraryUtility.GenerateRandomText(LibraryRandom.RandIntInRange(1,1024)); @@ -70,16 +59,16 @@ OBJECT Codeunit 51020 Test_Symmetric_Encryption_Mgt END; [Test] + [LineStart(867)] PROCEDURE AES_256_CBC_PKCS7_SetCipherFromBlob_EncryptDecrypt@1000000002(); VAR - SymmetricEncryption@1000000007 : Codeunit 50020; + SymmetricEncryption@1000000007 : Codeunit "Symmetric Encryption Mgt"; TextToEncrypt@1000000008 : Text; TextDecrypted@1000000009 : Text; TextEncrypted@1000000014 : Text; TextCipher@1000000011 : Text; - TempBlobCipher@1000000000 : Record 99008535; + TempBlobCipher@1000000000 : Record TempBlob; BEGIN - Initialize(); TextCipher := LibraryUtility.GenerateRandomText(LibraryRandom.RandIntInRange(1,64)); TextToEncrypt := LibraryUtility.GenerateRandomText(100000); // to stress the read buffer @@ -93,20 +82,20 @@ OBJECT Codeunit 51020 Test_Symmetric_Encryption_Mgt END; [Test] + [LineStart(879)] PROCEDURE AES_256_CBC_PKCS7_SetKeyIV_EncryptDecrypt@1000000018(); VAR - SymmetricEncryption@1000000007 : Codeunit 50020; + SymmetricEncryption@1000000007 : Codeunit "Symmetric Encryption Mgt"; 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; + DotNet_ArrayKey@1000000000 : Codeunit DotNet_Array; + DotNet_ArrayIV@1000000004 : Codeunit DotNet_Array; Convert@1000000002 : DotNet "'mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089'.System.Convert"; BEGIN - Initialize(); TextToEncrypt := 'Lorem ipsum dolor sit amet, consectetur adipiscing elit. Aliquam'; TextEncryptedExpected := 'LTQUy/6qPc/hxX87etScoQKXDqrbuuCVsmbIEsB2kqzHVL282etankz2kkxZojacuxu3wv7Q6htZOnXq49SrGGSUBrbJo2hJ2op62GxSmgc='; @@ -133,15 +122,15 @@ OBJECT Codeunit 51020 Test_Symmetric_Encryption_Mgt END; [Test] + [LineStart(904)] PROCEDURE AES_192_CBC_PKCS7_EncryptDecrypt@1000000027(); VAR - SymmetricEncryption@1000000003 : Codeunit 50020; + SymmetricEncryption@1000000003 : Codeunit "Symmetric Encryption Mgt"; TextCipher@1000000004 : Text; TextToEncrypt@1000000002 : Text; TextEncrypted@1000000001 : Text; TextDecrypted@1000000000 : Text; BEGIN - Initialize(); TextCipher := LibraryUtility.GenerateRandomText(LibraryRandom.RandIntInRange(1,64)); TextToEncrypt := LibraryUtility.GenerateRandomText(LibraryRandom.RandIntInRange(1,1024)); @@ -152,15 +141,15 @@ OBJECT Codeunit 51020 Test_Symmetric_Encryption_Mgt END; [Test] + [LineStart(913)] PROCEDURE AES_128_CBC_PKCS7_EncryptDecrypt@1000000005(); VAR - SymmetricEncryption@1000000003 : Codeunit 50020; + SymmetricEncryption@1000000003 : Codeunit "Symmetric Encryption Mgt"; TextCipher@1000000004 : Text; TextToEncrypt@1000000002 : Text; TextEncrypted@1000000001 : Text; TextDecrypted@1000000000 : Text; BEGIN - Initialize(); TextCipher := LibraryUtility.GenerateRandomText(8); TextToEncrypt := LibraryUtility.GenerateRandomText(LibraryRandom.RandIntInRange(1,1024)); @@ -171,28 +160,31 @@ OBJECT Codeunit 51020 Test_Symmetric_Encryption_Mgt END; [Test] + [LineStart(922)] PROCEDURE AES_256_CFB_PKCS7_EncryptDecrypt@1000000010(); VAR - SymmetricEncryption@1000000003 : Codeunit 50020; + SymmetricEncryption@1000000003 : Codeunit "Symmetric Encryption Mgt"; TextCipher@1000000004 : Text; TextToEncrypt@1000000002 : Text; TextEncrypted@1000000001 : Text; TextDecrypted@1000000000 : Text; + DotNet_CipherMode@1000000005 : Codeunit DotNet_CipherMode; BEGIN - Initialize(); TextCipher := LibraryUtility.GenerateRandomText(LibraryRandom.RandIntInRange(1,64)); TextToEncrypt := LibraryUtility.GenerateRandomText(1); - SymmetricEncryption.SetMode(Mode::CFB); + 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] + [LineStart(932)] PROCEDURE AES_256_CTS_PKCS7_EncryptDecrypt@1000000014(); VAR - SymmetricEncryption@1000000003 : Codeunit 50020; + SymmetricEncryption@1000000003 : Codeunit "Symmetric Encryption Mgt"; TextCipher@1000000004 : Text; TextToEncrypt@1000000002 : Text; TextEncrypted@1000000001 : Text; @@ -202,28 +194,31 @@ OBJECT Codeunit 51020 Test_Symmetric_Encryption_Mgt END; [Test] + [LineStart(935)] PROCEDURE AES_256_ECB_PKCS7_EncryptDecrypt@1000000012(); VAR - SymmetricEncryption@1000000003 : Codeunit 50020; + SymmetricEncryption@1000000003 : Codeunit "Symmetric Encryption Mgt"; TextCipher@1000000004 : Text; TextToEncrypt@1000000002 : Text; TextEncrypted@1000000001 : Text; TextDecrypted@1000000000 : Text; + DotNet_CipherMode@1000000005 : Codeunit DotNet_CipherMode; BEGIN - Initialize(); TextCipher := LibraryUtility.GenerateRandomText(LibraryRandom.RandIntInRange(1,64)); TextToEncrypt := LibraryUtility.GenerateRandomText(LibraryRandom.RandIntInRange(1,1024)); - SymmetricEncryption.SetMode(Mode::ECB); + 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] + [LineStart(945)] PROCEDURE AES_256_OFB_PKCS7_EncryptDecrypt@1000000015(); VAR - SymmetricEncryption@1000000003 : Codeunit 50020; + SymmetricEncryption@1000000003 : Codeunit "Symmetric Encryption Mgt"; TextCipher@1000000004 : Text; TextToEncrypt@1000000002 : Text; TextEncrypted@1000000001 : Text; @@ -233,88 +228,94 @@ OBJECT Codeunit 51020 Test_Symmetric_Encryption_Mgt END; [Test] + [LineStart(948)] PROCEDURE AES_256_CBC_ANSIX923_EncryptDecrypt@1000000008(); VAR - SymmetricEncryption@1000000007 : Codeunit 50020; + SymmetricEncryption@1000000007 : Codeunit "Symmetric Encryption Mgt"; TextCipher@1000000001 : Text; TextToEncrypt@1000000008 : Text; TextEncrypted@1000000000 : Text; TextDecrypted@1000000009 : Text; + DotNet_PaddingMode@1000000002 : Codeunit DotNet_PaddingMode; BEGIN - Initialize(); TextCipher := LibraryUtility.GenerateRandomText(LibraryRandom.RandIntInRange(1,64)); TextToEncrypt := LibraryUtility.GenerateRandomText(LibraryRandom.RandIntInRange(1,1024)); - SymmetricEncryption.SetPadding(Padding::ANSIX923); + 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] + [LineStart(958)] PROCEDURE AES_256_CBC_ISO10126_EncryptDecrypt@1000000011(); VAR - SymmetricEncryption@1000000007 : Codeunit 50020; + SymmetricEncryption@1000000007 : Codeunit "Symmetric Encryption Mgt"; TextCipher@1000000001 : Text; TextToEncrypt@1000000008 : Text; TextEncrypted@1000000000 : Text; TextDecrypted@1000000009 : Text; + DotNet_PaddingMode@1000000002 : Codeunit DotNet_PaddingMode; BEGIN - Initialize(); TextCipher := LibraryUtility.GenerateRandomText(LibraryRandom.RandIntInRange(1,64)); TextToEncrypt := LibraryUtility.GenerateRandomText(LibraryRandom.RandIntInRange(1,1024)); - SymmetricEncryption.SetPadding(Padding::ISO10126); + 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] + [LineStart(968)] PROCEDURE AES_256_CBC_Zeros_EncryptDecrypt@1000000013(); VAR - SymmetricEncryption@1000000007 : Codeunit 50020; + SymmetricEncryption@1000000007 : Codeunit "Symmetric Encryption Mgt"; TextCipher@1000000001 : Text; TextToEncrypt@1000000008 : Text; TextEncrypted@1000000000 : Text; TextDecrypted@1000000009 : Text; + DotNet_PaddingMode@1000000002 : Codeunit DotNet_PaddingMode; BEGIN - Initialize(); TextCipher := LibraryUtility.GenerateRandomText(LibraryRandom.RandIntInRange(1,64)); TextToEncrypt := LibraryUtility.GenerateRandomText(LibraryRandom.RandIntInRange(1,1024)); - SymmetricEncryption.SetPadding(Padding::Zeros); + 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] + [LineStart(978)] PROCEDURE AES_256_CBC_PKCS7_EncryptStringFail@1000000016(); VAR - SymmetricEncryption@1000000003 : Codeunit 50020; + SymmetricEncryption@1000000003 : Codeunit "Symmetric Encryption Mgt"; TextCipher@1000000004 : Text; TextToEncrypt@1000000002 : Text; TextEncrypted@1000000001 : Text; TextDecrypted@1000000000 : Text; BEGIN - Initialize(); TextCipher := ''; TextToEncrypt := ''; Assert.IsFalse(SymmetricEncryption.EncryptTextBase64(TextToEncrypt, TextEncrypted), E_EXPECTED_FAILURE); END; [Test] + [LineStart(983)] PROCEDURE AES_256_CBC_PKCS7_DecryptStringFail@1000000017(); VAR - SymmetricEncryption@1000000003 : Codeunit 50020; + SymmetricEncryption@1000000003 : Codeunit "Symmetric Encryption Mgt"; TextCipher@1000000004 : Text; TextToEncrypt@1000000001 : Text; TextToDecrypt@1000000002 : Text; TextDecrypted@1000000000 : Text; TextEncrypted@1000000005 : Text; BEGIN - Initialize(); TextCipher := LibraryUtility.GenerateRandomText(LibraryRandom.RandIntInRange(1,64)); TextToEncrypt := LibraryUtility.GenerateRandomText(LibraryRandom.RandIntInRange(10,100)); @@ -323,82 +324,82 @@ OBJECT Codeunit 51020 Test_Symmetric_Encryption_Mgt Assert.IsTrue(SymmetricEncryption.EncryptTextBase64(TextToEncrypt, TextEncrypted), E_EXPECTED_SUCCESS); // Mangle encrypted string - TextEncrypted[STRLEN(TextEncrypted)-2] := '_'; - TextEncrypted[STRLEN(TextEncrypted)-1] := '_'; + TextEncrypted[StrLen(TextEncrypted)-2] := '_'; + TextEncrypted[StrLen(TextEncrypted)-1] := '_'; Assert.IsFalse(SymmetricEncryption.DecryptTextBase64(TextEncrypted, TextDecrypted), E_EXPECTED_FAILURE); END; [Test] + [LineStart(996)] PROCEDURE DES_EncryptDecrypt@1000000006(); VAR - SymmetricEncryption@1000000003 : Codeunit 50020; + SymmetricEncryption@1000000003 : Codeunit "Symmetric Encryption Mgt"; TextCipher@1000000004 : Text; TextToEncrypt@1000000002 : Text; TextEncrypted@1000000001 : Text; TextDecrypted@1000000000 : Text; BEGIN - Initialize(); TextCipher := LibraryUtility.GenerateRandomText(LibraryRandom.RandIntInRange(1,64)); TextToEncrypt := LibraryUtility.GenerateRandomText(LibraryRandom.RandIntInRange(1,1024)); - SymmetricEncryption.SetAlgorithm(Algorithm::DES); + SymmetricEncryption.SetAlgorithm('DES'); SymmetricEncryption.SetCipher(TextCipher); EncryptDecryptText(SymmetricEncryption, TextToEncrypt, TextEncrypted, TextDecrypted); Assert.IsTrue(StringsAreEqual(TextToEncrypt, TextDecrypted), E_ENCRYPTDECRYPT_FAILED); END; [Test] + [LineStart(1005)] PROCEDURE RC2_EncryptDecrypt@1000000001(); VAR - SymmetricEncryption@1000000003 : Codeunit 50020; + SymmetricEncryption@1000000003 : Codeunit "Symmetric Encryption Mgt"; TextCipher@1000000004 : Text; TextToEncrypt@1000000002 : Text; TextEncrypted@1000000001 : Text; TextDecrypted@1000000000 : Text; BEGIN - Initialize(); TextCipher := LibraryUtility.GenerateRandomText(LibraryRandom.RandIntInRange(1,64)); TextToEncrypt := LibraryUtility.GenerateRandomText(LibraryRandom.RandIntInRange(1,1024)); - SymmetricEncryption.SetAlgorithm(Algorithm::RC2); + SymmetricEncryption.SetAlgorithm('RC2'); SymmetricEncryption.SetCipher(TextCipher); EncryptDecryptText(SymmetricEncryption, TextToEncrypt, TextEncrypted, TextDecrypted); Assert.IsTrue(StringsAreEqual(TextToEncrypt, TextDecrypted), E_ENCRYPTDECRYPT_FAILED); END; [Test] + [LineStart(1014)] PROCEDURE Rijndael_EncryptDecrypt@1000000003(); VAR - SymmetricEncryption@1000000003 : Codeunit 50020; + SymmetricEncryption@1000000003 : Codeunit "Symmetric Encryption Mgt"; TextCipher@1000000004 : Text; TextToEncrypt@1000000002 : Text; TextEncrypted@1000000001 : Text; TextDecrypted@1000000000 : Text; BEGIN - Initialize(); TextCipher := LibraryUtility.GenerateRandomText(LibraryRandom.RandIntInRange(1,64)); TextToEncrypt := LibraryUtility.GenerateRandomText(LibraryRandom.RandIntInRange(1,1024)); - SymmetricEncryption.SetAlgorithm(Algorithm::Rijndael); + SymmetricEncryption.SetAlgorithm('Rijndael'); SymmetricEncryption.SetCipher(TextCipher); EncryptDecryptText(SymmetricEncryption, TextToEncrypt, TextEncrypted, TextDecrypted); Assert.IsTrue(StringsAreEqual(TextToEncrypt, TextDecrypted), E_ENCRYPTDECRYPT_FAILED); END; [Test] + [LineStart(1023)] PROCEDURE TripleDES_EncryptDecrypt@1000000009(); VAR - SymmetricEncryption@1000000003 : Codeunit 50020; + SymmetricEncryption@1000000003 : Codeunit "Symmetric Encryption Mgt"; TextCipher@1000000004 : Text; TextToEncrypt@1000000002 : Text; TextEncrypted@1000000001 : Text; TextDecrypted@1000000000 : Text; BEGIN - Initialize(); TextCipher := LibraryUtility.GenerateRandomText(LibraryRandom.RandIntInRange(1,64)); TextToEncrypt := LibraryUtility.GenerateRandomText(LibraryRandom.RandIntInRange(1,1024)); - SymmetricEncryption.SetAlgorithm(Algorithm::TripleDES); + SymmetricEncryption.SetAlgorithm('TripleDES'); SymmetricEncryption.SetCipher(TextCipher); EncryptDecryptText(SymmetricEncryption, TextToEncrypt, TextEncrypted, TextDecrypted); Assert.IsTrue(StringsAreEqual(TextToEncrypt, TextDecrypted), E_ENCRYPTDECRYPT_FAILED); From 6499e71ab430b7f890471f2451a485dbf27b8c18 Mon Sep 17 00:00:00 2001 From: Phil Rios <30962795+quadfin@users.noreply.github.com> Date: Mon, 18 Feb 2019 11:52:39 -0800 Subject: [PATCH 5/5] Added return value to enum wrappers. Removed unused variables. Corrected export syntax (accidentally used ExportToNewSyntax in last commit) --- BaseApp/COD3025.TXT | 14 +-- BaseApp/COD3027.TXT | 23 +--- BaseApp/COD50010.TXT | 54 +++------ BaseApp/COD50012.TXT | 23 ++-- BaseApp/COD50013.TXT | 3 - BaseApp/COD50014.TXT | 47 +++----- BaseApp/COD50015.TXT | 35 ++---- BaseApp/COD50016.TXT | 35 ++---- BaseApp/COD50017.TXT | 14 +-- BaseApp/COD50020.TXT | 261 +++++++++++++++++++------------------------ Test/COD51010.TXT | 87 ++++++--------- Test/COD51012.TXT | 52 ++++----- Test/COD51013.TXT | 9 +- Test/COD51014.TXT | 34 +++--- Test/COD51020.TXT | 86 ++++++-------- 15 files changed, 308 insertions(+), 469 deletions(-) diff --git a/BaseApp/COD3025.TXT b/BaseApp/COD3025.TXT index bf92986..53babf4 100644 --- a/BaseApp/COD3025.TXT +++ b/BaseApp/COD3025.TXT @@ -18,22 +18,19 @@ OBJECT Codeunit 3025 DotNet_StreamWriter DotNetStreamWriter@1001 : DotNet "'mscorlib'.System.IO.StreamWriter"; [External] - [LineStart(2)] PROCEDURE Write@6(Text@1000 : Text); BEGIN DotNetStreamWriter.Write(Text); END; [External] - [LineStart(5)] PROCEDURE WriteLine@2(LineText@1000 : Text); BEGIN DotNetStreamWriter.WriteLine(LineText); END; [External] - [LineStart(8)] - PROCEDURE StreamWriter@1(VAR OutStream@1000 : OutStream;DotNet_Encoding@1001 : Codeunit DotNet_Encoding); + PROCEDURE StreamWriter@1(VAR OutStream@1000 : OutStream;DotNet_Encoding@1001 : Codeunit 3026); VAR DotNetEncoding@1002 : DotNet "'mscorlib'.System.Text.Encoding"; BEGIN @@ -42,8 +39,7 @@ OBJECT Codeunit 3025 DotNet_StreamWriter END; [External] - [LineStart(12)] - PROCEDURE StreamWriterFromDotNetStream@1000000001(VAR DotNet_Stream@1000 : Codeunit DotNet_Stream;DotNet_Encoding@1001 : Codeunit DotNet_Encoding); + 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"; @@ -54,40 +50,34 @@ OBJECT Codeunit 3025 DotNet_StreamWriter END; [External] - [LineStart(17)] PROCEDURE StreamWriterWithDefaultEncoding@7(VAR OutStream@1000 : OutStream); BEGIN DotNetStreamWriter := DotNetStreamWriter.StreamWriter(OutStream); END; [External] - [LineStart(20)] PROCEDURE Flush@3(); BEGIN DotNetStreamWriter.Flush; END; [External] - [LineStart(23)] PROCEDURE Close@4(); BEGIN DotNetStreamWriter.Close; END; [External] - [LineStart(26)] PROCEDURE Dispose@5(); BEGIN DotNetStreamWriter.Dispose; END; - [LineStart(29)] PROCEDURE GetStreamWriter@1000000000(VAR DotNetStreamWriter2@1000000000 : DotNet "'mscorlib'.System.IO.StreamWriter"); BEGIN DotNetStreamWriter2 := DotNetStreamWriter; END; - [LineStart(32)] PROCEDURE SetStreamWriter@1000000002(VAR DotNetStreamWriter2@1000000000 : DotNet "'mscorlib'.System.IO.StreamWriter"); BEGIN DotNetStreamWriter := DotNetStreamWriter2; diff --git a/BaseApp/COD3027.TXT b/BaseApp/COD3027.TXT index 4375dbd..52e7657 100644 --- a/BaseApp/COD3027.TXT +++ b/BaseApp/COD3027.TXT @@ -18,8 +18,7 @@ OBJECT Codeunit 3027 DotNet_StreamReader DotNetStreamReader@1000 : DotNet "'mscorlib'.System.IO.StreamReader"; [External] - [LineStart(37)] - PROCEDURE StreamReader@1(VAR InputStream@1000 : InStream;DotNet_Encoding@1001 : Codeunit DotNet_Encoding); + PROCEDURE StreamReader@1(VAR InputStream@1000 : InStream;DotNet_Encoding@1001 : Codeunit 3026); VAR DotNetEncoding@1002 : DotNet "'mscorlib'.System.Text.Encoding"; BEGIN @@ -28,8 +27,7 @@ OBJECT Codeunit 3027 DotNet_StreamReader END; [External] - [LineStart(41)] - PROCEDURE StreamReaderFromDotNetStream@1000000000(VAR DotNet_Stream@1000 : Codeunit DotNet_Stream;DotNet_Encoding@1001 : Codeunit DotNet_Encoding); + 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"; @@ -41,61 +39,52 @@ OBJECT Codeunit 3027 DotNet_StreamReader END; [External] - [LineStart(47)] PROCEDURE StreamReaderDetectEncoding@2(VAR InputStream@1000 : InStream;DetectEncodingFromByteOrderMarks@1001 : Boolean); BEGIN DotNetStreamReader := DotNetStreamReader.StreamReader(InputStream,DetectEncodingFromByteOrderMarks); END; [External] - [LineStart(50)] PROCEDURE Close@3(); BEGIN DotNetStreamReader.Close; END; [External] - [LineStart(53)] PROCEDURE Dispose@4(); BEGIN DotNetStreamReader.Dispose; END; [External] - [LineStart(56)] PROCEDURE EndOfStream@6() : Boolean; BEGIN - exit(DotNetStreamReader.EndOfStream); + EXIT(DotNetStreamReader.EndOfStream); END; [External] - [LineStart(59)] - PROCEDURE CurrentEncoding@7(VAR DotNet_Encoding@1000 : Codeunit DotNet_Encoding); + PROCEDURE CurrentEncoding@7(VAR DotNet_Encoding@1000 : Codeunit 3026); BEGIN DotNet_Encoding.SetEncoding(DotNetStreamReader.CurrentEncoding); END; [External] - [LineStart(62)] PROCEDURE ReadLine@8() : Text; BEGIN - exit(DotNetStreamReader.ReadLine); + EXIT(DotNetStreamReader.ReadLine); END; [External] - [LineStart(65)] PROCEDURE ReadToEnd@9() : Text; BEGIN - exit(DotNetStreamReader.ReadToEnd); + EXIT(DotNetStreamReader.ReadToEnd); END; - [LineStart(68)] PROCEDURE GetStreamReader@1000000001(VAR DotNetStreamReader2@1000000000 : DotNet "'mscorlib'.System.IO.StreamReader"); BEGIN DotNetStreamReader2 := DotNetStreamReader; END; - [LineStart(71)] PROCEDURE SetStreamReader@1000000002(VAR DotNetStreamReader2@1000000000 : DotNet "'mscorlib'.System.IO.StreamReader"); BEGIN DotNetStreamReader := DotNetStreamReader2; diff --git a/BaseApp/COD50010.TXT b/BaseApp/COD50010.TXT index 0a65352..6bd6c04 100644 --- a/BaseApp/COD50010.TXT +++ b/BaseApp/COD50010.TXT @@ -19,36 +19,31 @@ OBJECT Codeunit 50010 DotNet_SymmetricAlgorithm E_INVALID_ALGORITHM@1000000001 : TextConst 'ENU=Invalid Algorithm'; [External] - [LineStart(76)] PROCEDURE GetBlockSize@1000000000() : Integer; BEGIN - exit(DotNetSymmetricAlgorithm.BlockSize); + EXIT(DotNetSymmetricAlgorithm.BlockSize); END; [External] - [LineStart(79)] PROCEDURE SetBlockSize@1000000027(BlockSize@1000000000 : Integer); BEGIN DotNetSymmetricAlgorithm.BlockSize := BlockSize; END; [External] - [LineStart(82)] PROCEDURE GetFeedbackSize@1000000007() : Integer; BEGIN - exit(DotNetSymmetricAlgorithm.FeedbackSize); + EXIT(DotNetSymmetricAlgorithm.FeedbackSize); END; [External] - [LineStart(85)] PROCEDURE SetFeedbackSize@1000000006(FeedbackSize@1000000000 : Integer); BEGIN DotNetSymmetricAlgorithm.FeedbackSize := FeedbackSize; END; [External] - [LineStart(88)] - PROCEDURE GetIV@1000000001(VAR DotNet_Array@1000000000 : Codeunit DotNet_Array); + PROCEDURE GetIV@1000000001(VAR DotNet_Array@1000000000 : Codeunit 3000); VAR DotNetArray@1000000001 : DotNet "'mscorlib'.System.Array"; BEGIN @@ -58,8 +53,7 @@ OBJECT Codeunit 50010 DotNet_SymmetricAlgorithm END; [External] - [LineStart(93)] - PROCEDURE SetIV@1000000023(VAR DotNet_Array@1000000000 : Codeunit DotNet_Array); + PROCEDURE SetIV@1000000023(VAR DotNet_Array@1000000000 : Codeunit 3000); VAR DotNetArray@1000000001 : DotNet "'mscorlib'.System.Array"; BEGIN @@ -68,8 +62,7 @@ OBJECT Codeunit 50010 DotNet_SymmetricAlgorithm END; [External] - [LineStart(97)] - PROCEDURE GetKey@1000000002(VAR DotNet_Array@1000000000 : Codeunit DotNet_Array); + PROCEDURE GetKey@1000000002(VAR DotNet_Array@1000000000 : Codeunit 3000); VAR DotNetArray@1000000001 : DotNet "'mscorlib'.System.Array"; BEGIN @@ -79,8 +72,7 @@ OBJECT Codeunit 50010 DotNet_SymmetricAlgorithm END; [External] - [LineStart(102)] - PROCEDURE SetKey@1000000021(VAR DotNet_Array@1000000000 : Codeunit DotNet_Array); + PROCEDURE SetKey@1000000021(VAR DotNet_Array@1000000000 : Codeunit 3000); VAR DotNetArray@1000000001 : DotNet "'mscorlib'.System.Array"; BEGIN @@ -89,32 +81,29 @@ OBJECT Codeunit 50010 DotNet_SymmetricAlgorithm END; [External] - [LineStart(106)] PROCEDURE GetKeySize@1000000003() : Integer; BEGIN - exit(DotNetSymmetricAlgorithm.KeySize); + EXIT(DotNetSymmetricAlgorithm.KeySize); END; [External] - [LineStart(109)] PROCEDURE SetKeySize@1000000018(KeySize@1000000000 : Integer); BEGIN DotNetSymmetricAlgorithm.KeySize := KeySize; END; [External] - [LineStart(112)] - PROCEDURE GetMode@1000000004(VAR DotNet_CipherMode@1000000000 : Codeunit DotNet_CipherMode); + 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] - [LineStart(116)] - PROCEDURE SetMode@1000000020(VAR DotNet_CipherMode@1000000000 : Codeunit DotNet_CipherMode); + PROCEDURE SetMode@1000000020(VAR DotNet_CipherMode@1000000000 : Codeunit 50015); VAR DotNetCipherMode@1000000001 : DotNet "'mscorlib'.System.Security.Cryptography.CipherMode"; BEGIN @@ -123,18 +112,17 @@ OBJECT Codeunit 50010 DotNet_SymmetricAlgorithm END; [External] - [LineStart(120)] - PROCEDURE GetPadding@1000000005(VAR DotNet_PaddingMode@1000000001 : Codeunit DotNet_PaddingMode) : Integer; + 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] - [LineStart(124)] - PROCEDURE SetPadding@1000000019(VAR DotNet_PaddingMode@1000000002 : Codeunit DotNet_PaddingMode); + PROCEDURE SetPadding@1000000019(VAR DotNet_PaddingMode@1000000002 : Codeunit 50016); VAR DotNetPaddingMode@1000000001 : DotNet "'mscorlib'.System.Security.Cryptography.PaddingMode"; BEGIN @@ -143,26 +131,23 @@ OBJECT Codeunit 50010 DotNet_SymmetricAlgorithm END; [External] - [LineStart(128)] PROCEDURE Create@1000000028(Algorithm@1000000000 : Text); BEGIN - if not (UpperCase(Algorithm) in ['AES','DES','RC2','RIJNDAEL','TRIPLEDES']) then - Error(E_INVALID_ALGORITHM); + IF NOT (UPPERCASE(Algorithm) IN ['AES','DES','RC2','RIJNDAEL','TRIPLEDES']) THEN + ERROR(E_INVALID_ALGORITHM); Dispose(); DotNetSymmetricAlgorithm := DotNetSymmetricAlgorithm.Create(Algorithm); END; [External] - [LineStart(134)] PROCEDURE Dispose@1000000008(); BEGIN - if not IsNull(DotNetSymmetricAlgorithm) then + IF NOT ISNULL(DotNetSymmetricAlgorithm) THEN DotNetSymmetricAlgorithm.Dispose(); END; [External] - [LineStart(138)] - PROCEDURE CreateEncryptor@1000000009(VAR DotNet_ICryptoTransform@1000000000 : Codeunit DotNet_ICryptoTransform); + PROCEDURE CreateEncryptor@1000000009(VAR DotNet_ICryptoTransform@1000000000 : Codeunit 50013); VAR DotNetICryptoTransform@1000000001 : DotNet "'mscorlib'.System.Security.Cryptography.ICryptoTransform"; BEGIN @@ -171,8 +156,7 @@ OBJECT Codeunit 50010 DotNet_SymmetricAlgorithm END; [External] - [LineStart(142)] - PROCEDURE CreateDecryptor@1000000015(VAR DotNet_ICryptoTransform@1000000000 : Codeunit DotNet_ICryptoTransform); + PROCEDURE CreateDecryptor@1000000015(VAR DotNet_ICryptoTransform@1000000000 : Codeunit 50013); VAR DotNetICryptoTransform@1000000001 : DotNet "'mscorlib'.System.Security.Cryptography.ICryptoTransform"; BEGIN @@ -180,13 +164,11 @@ OBJECT Codeunit 50010 DotNet_SymmetricAlgorithm DotNet_ICryptoTransform.SetICryptoTransform(DotNetICryptoTransform); END; - [LineStart(146)] 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; - [LineStart(149)] PROCEDURE SetSymmetricAlgorithm@1000000014(VAR DotNetSymmetricAlgorithm2@1000000000 : DotNet "'mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089'.System.Security.Cryptography.SymmetricAlgorithm"); BEGIN DotNetSymmetricAlgorithm := DotNetSymmetricAlgorithm2; diff --git a/BaseApp/COD50012.TXT b/BaseApp/COD50012.TXT index 8a340c7..377d7c6 100644 --- a/BaseApp/COD50012.TXT +++ b/BaseApp/COD50012.TXT @@ -19,17 +19,15 @@ OBJECT Codeunit 50012 DotNet_HashAlgorithm EALGORITHM@1000000001 : TextConst 'ENU=Invalid Hash Algorithm'; [External] - [LineStart(154)] PROCEDURE Create@1000000005(HashAlgorithm@1000000000 : Text); BEGIN - if not (UpperCase(HashAlgorithm) in ['SHA1','MD5','SHA256','SHA384','SHA512']) then - Error(EALGORITHM); + IF NOT (UPPERCASE(HashAlgorithm) IN ['SHA1','MD5','SHA256','SHA384','SHA512']) THEN + ERROR(EALGORITHM); DotNetHashAlgorithm := DotNetHashAlgorithm.Create(HashAlgorithm); END; [External] - [LineStart(159)] - PROCEDURE ComputeHash@1000000001(VAR DotNet_ArrayData@1000000001 : Codeunit DotNet_Array;VAR DotNet_ArrayHash@1000 : Codeunit DotNet_Array); + PROCEDURE ComputeHash@1000000001(VAR DotNet_ArrayData@1000000001 : Codeunit 3000;VAR DotNet_ArrayHash@1000 : Codeunit 3000); VAR DotNetArray@1000000000 : DotNet "'mscorlib'.System.Array"; BEGIN @@ -38,40 +36,35 @@ OBJECT Codeunit 50012 DotNet_HashAlgorithm END; [External] - [LineStart(163)] - PROCEDURE ComputeHashFromText@1000000000(VAR Text@1000000001 : Text;VAR DotNet_Array@1000 : Codeunit DotNet_Array); + 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 DotNet_Encoding; + DotNet_Encoding@1000000003 : Codeunit 3026; BEGIN - if Text = '' then - exit; + IF Text = '' THEN + EXIT; DotNet_Encoding.UTF8; DotNet_Encoding.GetEncoding(DotNetEncoding); DotNet_Array.SetArray(DotNetHashAlgorithm.ComputeHash(DotNetEncoding.GetBytes(Text))); END; [External] - [LineStart(170)] - PROCEDURE ComputeHashFromInStream@5(VAR IStream@1000000001 : InStream;VAR DotNet_Array@1000 : Codeunit DotNet_Array); + PROCEDURE ComputeHashFromInStream@5(VAR IStream@1000000001 : InStream;VAR DotNet_Array@1000 : Codeunit 3000); BEGIN DotNet_Array.SetArray(DotNetHashAlgorithm.ComputeHash(IStream)); END; [External] - [LineStart(173)] PROCEDURE Dispose@1000000006(); BEGIN DotNetHashAlgorithm.Dispose(); END; - [LineStart(176)] PROCEDURE GetHashAlgorithm@2(VAR DotNetHashAlgorithm2@1000000001 : DotNet "'mscorlib'.System.Security.Cryptography.HashAlgorithm"); BEGIN DotNetHashAlgorithm2 := DotNetHashAlgorithm; END; - [LineStart(179)] PROCEDURE SetHashAlgorithm@3(VAR DotNetHashAlgorithm2@1000000000 : DotNet "'mscorlib'.System.Security.Cryptography.HashAlgorithm"); BEGIN DotNetHashAlgorithm := DotNetHashAlgorithm2; diff --git a/BaseApp/COD50013.TXT b/BaseApp/COD50013.TXT index 77d1212..221e63b 100644 --- a/BaseApp/COD50013.TXT +++ b/BaseApp/COD50013.TXT @@ -18,19 +18,16 @@ OBJECT Codeunit 50013 DotNet_ICryptoTransform DotNetICryptoTransform@1000000000 : DotNet "'mscorlib'.System.Security.Cryptography.ICryptoTransform"; [External] - [LineStart(184)] PROCEDURE Dispose@1000000006(); BEGIN DotNetICryptoTransform.Dispose() END; - [LineStart(187)] PROCEDURE GetICryptoTransform@2(VAR DotNetICryptoTransform2@1000000001 : DotNet "'mscorlib'.System.Security.Cryptography.ICryptoTransform"); BEGIN DotNetICryptoTransform2 := DotNetICryptoTransform END; - [LineStart(190)] PROCEDURE SetICryptoTransform@3(VAR DotNetICryptoTransform2@1000000000 : DotNet "'mscorlib'.System.Security.Cryptography.ICryptoTransform"); BEGIN DotNetICryptoTransform := DotNetICryptoTransform2 diff --git a/BaseApp/COD50014.TXT b/BaseApp/COD50014.TXT index 4e6367e..4cb763e 100644 --- a/BaseApp/COD50014.TXT +++ b/BaseApp/COD50014.TXT @@ -18,8 +18,7 @@ OBJECT Codeunit 50014 DotNet_CryptoStream DotNetCryptoStream@1000000000 : DotNet "'mscorlib'.System.Security.Cryptography.CryptoStream"; [External] - [LineStart(195)] - PROCEDURE CryptoStream@1000000001(VAR DotNet_Stream@1000000000 : Codeunit DotNet_Stream;VAR DotNet_ICryptoTransform@1000000001 : Codeunit DotNet_ICryptoTransform;VAR DotNet_CryptoStreamMode@1000000005 : Codeunit DotNet_CryptoStreamMode); + 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"; @@ -32,8 +31,7 @@ OBJECT Codeunit 50014 DotNet_CryptoStream END; [External] - [LineStart(201)] - PROCEDURE CryptoInStream@1000000005(IStream@1000000000 : InStream;VAR DotNet_ICryptoTransform@1000000001 : Codeunit DotNet_ICryptoTransform); + 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"; @@ -43,8 +41,7 @@ OBJECT Codeunit 50014 DotNet_CryptoStream END; [External] - [LineStart(205)] - PROCEDURE CryptoOutStream@1000000000(OStream@1000000000 : OutStream;VAR DotNet_ICryptoTransform@1000000001 : Codeunit DotNet_ICryptoTransform); + 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"; @@ -54,64 +51,56 @@ OBJECT Codeunit 50014 DotNet_CryptoStream END; [External] - [LineStart(209)] PROCEDURE CanRead@1000000002() : Boolean; BEGIN - if not IsNull(DotNetCryptoStream) then - exit(DotNetCryptoStream.CanRead); - exit(false); + IF NOT ISNULL(DotNetCryptoStream) THEN + EXIT(DotNetCryptoStream.CanRead); + EXIT(FALSE); END; [External] - [LineStart(214)] PROCEDURE CanSeek@1000000003() : Boolean; BEGIN - if not IsNull(DotNetCryptoStream) then - exit(DotNetCryptoStream.CanSeek); - exit(false); + IF NOT ISNULL(DotNetCryptoStream) THEN + EXIT(DotNetCryptoStream.CanSeek); + EXIT(FALSE); END; [External] - [LineStart(219)] PROCEDURE CanWrite@1000000004() : Boolean; BEGIN - if not IsNull(DotNetCryptoStream) then - exit(DotNetCryptoStream.CanWrite); - exit(false); + IF NOT ISNULL(DotNetCryptoStream) THEN + EXIT(DotNetCryptoStream.CanWrite); + EXIT(FALSE); END; [External] - [LineStart(224)] PROCEDURE Length@1000000008() : Integer; BEGIN - if not IsNull(DotNetCryptoStream) then - exit(DotNetCryptoStream.Length); - exit(0); + IF NOT ISNULL(DotNetCryptoStream) THEN + EXIT(DotNetCryptoStream.Length); + EXIT(0); END; [External] - [LineStart(229)] PROCEDURE Position@1000000007() : Integer; BEGIN - if not IsNull(DotNetCryptoStream) then - exit(DotNetCryptoStream.Position); - exit(0); + IF NOT ISNULL(DotNetCryptoStream) THEN + EXIT(DotNetCryptoStream.Position); + EXIT(0); END; [External] - [LineStart(234)] PROCEDURE Dispose@1000000006(); BEGIN DotNetCryptoStream.Dispose(); END; - [LineStart(237)] PROCEDURE GetCryptoStream@2(VAR DotNetCryptoStream2@1000000000 : DotNet "'mscorlib'.System.Security.Cryptography.CryptoStream"); BEGIN DotNetCryptoStream2 := DotNetCryptoStream; END; - [LineStart(240)] PROCEDURE SetCryptoStream@3(VAR DotNetCryptoStream2@1000000000 : DotNet "'mscorlib'.System.Security.Cryptography.CryptoStream"); BEGIN DotNetCryptoStream := DotNetCryptoStream2; diff --git a/BaseApp/COD50015.TXT b/BaseApp/COD50015.TXT index c5596a7..8469b34 100644 --- a/BaseApp/COD50015.TXT +++ b/BaseApp/COD50015.TXT @@ -18,67 +18,54 @@ OBJECT Codeunit 50015 DotNet_CipherMode DotNetCipherMode@1000000000 : DotNet "'mscorlib'.System.Security.Cryptography.CipherMode"; [External] - [LineStart(245)] - PROCEDURE CBC@1000000000(); - VAR - Mode@1000000000 : Integer; + PROCEDURE CBC@1000000000() : Integer; BEGIN DotNetCipherMode := DotNetCipherMode.CBC; + EXIT(DotNetCipherMode); END; [External] - [LineStart(248)] - PROCEDURE ECB@1000000001(); - VAR - Mode@1000000000 : Integer; + PROCEDURE ECB@1000000001() : Integer; BEGIN DotNetCipherMode := DotNetCipherMode.ECB; + EXIT(DotNetCipherMode); END; [External] - [LineStart(251)] - PROCEDURE OFB@1000000002(); - VAR - Mode@1000000000 : Integer; + PROCEDURE OFB@1000000002() : Integer; BEGIN DotNetCipherMode := DotNetCipherMode.OFB; + EXIT(DotNetCipherMode); END; [External] - [LineStart(254)] - PROCEDURE CFB@1000000003(); - VAR - Mode@1000000000 : Integer; + PROCEDURE CFB@1000000003() : Integer; BEGIN DotNetCipherMode := DotNetCipherMode.CFB; + EXIT(DotNetCipherMode); END; [External] - [LineStart(257)] - PROCEDURE CTS@1000000004(); - VAR - Mode@1000000000 : Integer; + PROCEDURE CTS@1000000004() : Integer; BEGIN DotNetCipherMode := DotNetCipherMode.CTS; + EXIT(DotNetCipherMode); END; [External] - [LineStart(260)] PROCEDURE Value@1000000005() : Integer; VAR Mode@1000000000 : Integer; BEGIN Mode := DotNetCipherMode; - exit(Mode); + EXIT(Mode); END; - [LineStart(264)] PROCEDURE GetCipherMode@1000000006(VAR DotNetCipherMode2@1000000000 : DotNet "'mscorlib'.System.Security.Cryptography.CipherMode"); BEGIN DotNetCipherMode2 := DotNetCipherMode; END; - [LineStart(267)] PROCEDURE SetCipherMode@1000000007(VAR DotNetCipherMode2@1000000000 : DotNet "'mscorlib'.System.Security.Cryptography.CipherMode"); BEGIN DotNetCipherMode := DotNetCipherMode2; diff --git a/BaseApp/COD50016.TXT b/BaseApp/COD50016.TXT index bad27b8..ac14a8e 100644 --- a/BaseApp/COD50016.TXT +++ b/BaseApp/COD50016.TXT @@ -18,67 +18,54 @@ OBJECT Codeunit 50016 DotNet_PaddingMode DotNetPaddingMode@1000000000 : DotNet "'mscorlib'.System.Security.Cryptography.PaddingMode"; [External] - [LineStart(272)] - PROCEDURE None@1000000000(); - VAR - Mode@1000000000 : Integer; + PROCEDURE None@1000000000() : Integer; BEGIN DotNetPaddingMode := DotNetPaddingMode.None; + EXIT(DotNetPaddingMode); END; [External] - [LineStart(275)] - PROCEDURE PKCS7@1000000001(); - VAR - Mode@1000000000 : Integer; + PROCEDURE PKCS7@1000000001() : Integer; BEGIN DotNetPaddingMode := DotNetPaddingMode.PKCS7; + EXIT(DotNetPaddingMode); END; [External] - [LineStart(278)] - PROCEDURE Zeros@1000000002(); - VAR - Mode@1000000000 : Integer; + PROCEDURE Zeros@1000000002() : Integer; BEGIN DotNetPaddingMode := DotNetPaddingMode.Zeros; + EXIT(DotNetPaddingMode); END; [External] - [LineStart(281)] - PROCEDURE ANSIX923@1000000003(); - VAR - Mode@1000000000 : Integer; + PROCEDURE ANSIX923@1000000003() : Integer; BEGIN DotNetPaddingMode := DotNetPaddingMode.ANSIX923; + EXIT(DotNetPaddingMode); END; [External] - [LineStart(284)] - PROCEDURE ISO10126@1000000004(); - VAR - Mode@1000000000 : Integer; + PROCEDURE ISO10126@1000000004() : Integer; BEGIN DotNetPaddingMode := DotNetPaddingMode.ISO10126; + EXIT(DotNetPaddingMode); END; [External] - [LineStart(287)] PROCEDURE Value@1000000007() : Integer; VAR PaddingMode@1000000000 : Integer; BEGIN PaddingMode := DotNetPaddingMode; - exit(PaddingMode); + EXIT(PaddingMode); END; - [LineStart(291)] PROCEDURE GetPaddingMode@1000000005(VAR DotNetPaddingMode2@1000000000 : DotNet "'mscorlib'.System.Security.Cryptography.PaddingMode"); BEGIN DotNetPaddingMode2 := DotNetPaddingMode; END; - [LineStart(294)] PROCEDURE SetPaddingMode@1000000006(VAR DotNetPaddingMode2@1000000000 : DotNet "'mscorlib'.System.Security.Cryptography.PaddingMode"); BEGIN DotNetPaddingMode := DotNetPaddingMode2; diff --git a/BaseApp/COD50017.TXT b/BaseApp/COD50017.TXT index 88e1610..e70951a 100644 --- a/BaseApp/COD50017.TXT +++ b/BaseApp/COD50017.TXT @@ -18,30 +18,24 @@ OBJECT Codeunit 50017 DotNet_CryptoStreamMode DotNetCryptoStreamMode@1000000000 : DotNet "'mscorlib'.System.Security.Cryptography.CryptoStreamMode"; [External] - [LineStart(299)] - PROCEDURE Read@1000000000(); - VAR - Mode@1000000000 : Integer; + PROCEDURE Read@1000000000() : Integer; BEGIN DotNetCryptoStreamMode := DotNetCryptoStreamMode.Read; + EXIT(DotNetCryptoStreamMode); END; [External] - [LineStart(302)] - PROCEDURE Write@1000000001(); - VAR - Mode@1000000000 : Integer; + PROCEDURE Write@1000000001() : Integer; BEGIN DotNetCryptoStreamMode := DotNetCryptoStreamMode.Write; + EXIT(DotNetCryptoStreamMode); END; - [LineStart(305)] PROCEDURE GetCryptoStreamMode@1000000005(VAR DotNetCryptoStreamMode2@1000000000 : DotNet "'mscorlib'.System.Security.Cryptography.CryptoStreamMode"); BEGIN DotNetCryptoStreamMode2 := DotNetCryptoStreamMode; END; - [LineStart(308)] PROCEDURE SetCryptoStreamMode@1000000006(VAR DotNetCryptoStreamMode2@1000000000 : DotNet "'mscorlib'.System.Security.Cryptography.CryptoStreamMode"); BEGIN DotNetCryptoStreamMode := DotNetCryptoStreamMode2; diff --git a/BaseApp/COD50020.TXT b/BaseApp/COD50020.TXT index 8ed74e1..eaa3d9a 100644 --- a/BaseApp/COD50020.TXT +++ b/BaseApp/COD50020.TXT @@ -22,58 +22,54 @@ OBJECT Codeunit 50020 Symmetric Encryption Mgt SymmetricAlgorithm@1000000003 : Text; DotNetCipherMode@1000000002 : DotNet "'mscorlib'.System.Security.Cryptography.CipherMode"; DotNetPaddingMode@1000000005 : DotNet "'mscorlib'.System.Security.Cryptography.PaddingMode"; - DotNet_ArrayKey@1000000008 : Codeunit DotNet_Array; - DotNet_ArrayIV@1000000007 : Codeunit DotNet_Array; + DotNet_ArrayKey@1000000008 : Codeunit 3000; + DotNet_ArrayIV@1000000007 : Codeunit 3000; E_NO_CIPHER@1000000004 : TextConst 'ENU=SymmetricAlgorithm - cipher not defined'; [External] - [LineStart(315)] PROCEDURE SetCipher@1000000015(VAR CipherText@1000000000 : Text); VAR - TempBlob@1000000001 : Record TempBlob; + 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; + IF CipherText = '' THEN + EXIT; TempBlob.WriteAsText(CipherText, TEXTENCODING::UTF8); - if TrySetCipher(TempBlob) then ; + IF TrySetCipher(TempBlob) THEN ; END; [External] - [LineStart(326)] - PROCEDURE SetCipherFromBlob@1000000014(VAR TempBlob@1000000000 : Record TempBlob); + PROCEDURE SetCipherFromBlob@1000000014(VAR TempBlob@1000000000 : Record 99008535); BEGIN - if TrySetCipher(TempBlob) then ; + IF TrySetCipher(TempBlob) THEN ; END; [External] - [LineStart(330)] PROCEDURE Base64ToPlainText@1000000053(Base64Text@1000000000 : Text) : Text; VAR - DotNet_Encoding@1000000001 : Codeunit DotNet_Encoding; - DotNet_Convert@1000000002 : Codeunit DotNet_Convert; + 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(''); + IF Base64Text = '' THEN + EXIT(''); DotNet_Encoding.UTF8; DotNet_Encoding.GetEncoding(DotNetEncoding); DotNet_Convert.GetConvert(DotNetConvert); - exit(DotNetEncoding.GetString(DotNetConvert.FromBase64String(Base64Text))); + EXIT(DotNetEncoding.GetString(DotNetConvert.FromBase64String(Base64Text))); // Public Interface ====================================================================================== END; [External] - [LineStart(342)] PROCEDURE SetAlgorithm@1000000023(Algorithm@1000000000 : Text); BEGIN @@ -81,7 +77,6 @@ OBJECT Codeunit 50020 Symmetric Encryption Mgt END; [External] - [LineStart(346)] PROCEDURE SetKeySize@1000000021(Size@1000000000 : Integer); BEGIN @@ -89,7 +84,6 @@ OBJECT Codeunit 50020 Symmetric Encryption Mgt END; [External] - [LineStart(350)] PROCEDURE SetBlockSize@1000000022(Size@1000000000 : Integer); BEGIN @@ -97,174 +91,161 @@ OBJECT Codeunit 50020 Symmetric Encryption Mgt END; [External] - [LineStart(354)] - PROCEDURE SetMode@1000000024(VAR DotNet_CipherMode@1000000000 : Codeunit DotNet_CipherMode); + PROCEDURE SetMode@1000000024(VAR DotNet_CipherMode@1000000000 : Codeunit 50015); BEGIN DotNet_CipherMode.GetCipherMode(DotNetCipherMode); END; [External] - [LineStart(357)] - PROCEDURE SetPadding@1000000000(VAR DotNet_PaddingMode@1000000000 : Codeunit DotNet_PaddingMode); + PROCEDURE SetPadding@1000000000(VAR DotNet_PaddingMode@1000000000 : Codeunit 50016); BEGIN DotNet_PaddingMode.GetPaddingMode(DotNetPaddingMode); END; [External] - [LineStart(360)] - PROCEDURE SetKey@1000000008(VAR DotNet_Array@1000000000 : Codeunit DotNet_Array); + PROCEDURE SetKey@1000000008(VAR DotNet_Array@1000000000 : Codeunit 3000); BEGIN DotNet_Array.Clone(DotNet_ArrayKey); END; [External] - [LineStart(364)] - PROCEDURE SetIV@1000000009(VAR DotNet_Array@1000000000 : Codeunit DotNet_Array); + PROCEDURE SetIV@1000000009(VAR DotNet_Array@1000000000 : Codeunit 3000); BEGIN DotNet_Array.Clone(DotNet_ArrayIV); END; [External] - [LineStart(368)] PROCEDURE EncryptTextBase64@1000000001(UnEncryptedText@1000000000 : Text;VAR EncryptedTextBase64@1000000003 : Text) : Boolean; VAR Result@1000000002 : Boolean; BEGIN - if StrLen(UnEncryptedText) > 0 then + IF STRLEN(UnEncryptedText) > 0 THEN Result := TryEncryptTextBase64(UnEncryptedText, EncryptedTextBase64); - ClearLastError; - exit(Result); + CLEARLASTERROR; + EXIT(Result); END; [External] - [LineStart(375)] PROCEDURE DecryptTextBase64@1000000002(EncryptedText@1000000000 : Text;VAR UnEncryptedText@1000000003 : Text) : Boolean; VAR Result@1000000002 : Boolean; BEGIN - if StrLen(EncryptedText) > 0 then + IF STRLEN(EncryptedText) > 0 THEN Result := TryDecryptTextBase64(EncryptedText, UnEncryptedText); - ClearLastError; - exit(Result); + CLEARLASTERROR; + EXIT(Result); END; [External] - [LineStart(382)] - PROCEDURE EncryptTempBlob@1000000006(VAR UnEncryptedTempBlob@1000000000 : Record TempBlob;VAR EncryptedTempBlob@1000000003 : Record TempBlob) : Boolean; + 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); + CLEARLASTERROR; + EXIT(Result); END; [External] - [LineStart(388)] - PROCEDURE DecryptTempBlob@1000000005(VAR EncryptedTempBlob@1000000000 : Record TempBlob;VAR DecryptedTempBlob@1000000003 : Record TempBlob) : Boolean; + 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); + CLEARLASTERROR; + EXIT(Result); END; [External] - [LineStart(394)] PROCEDURE EncryptStream@1000000003(VAR UnEncryptedStream@1000000002 : InStream;VAR EncryptedStream@1000000000 : OutStream) : Boolean; VAR Result@1000000003 : Boolean; BEGIN Result := TryEncryptStream(UnEncryptedStream, EncryptedStream); - ClearLastError; - exit(Result); + CLEARLASTERROR; + EXIT(Result); END; [External] - [LineStart(400)] PROCEDURE DecryptStream@1000000004(VAR EncryptedStream@1000000001 : InStream;VAR UnEncryptedStream@1000000000 : OutStream) : Boolean; VAR Result@1000000003 : Boolean; BEGIN Result := TryDecryptStream(EncryptedStream, UnEncryptedStream); - ClearLastError; - exit(Result); + CLEARLASTERROR; + EXIT(Result); // Private Interface ====================================================================================== END; - [LineStart(408)] LOCAL PROCEDURE KeyLengthInBytes@1000000017() : Integer; VAR Size@1000000000 : Integer; BEGIN - if KeySize = 0 then + IF KeySize = 0 THEN KeySize := 256; - exit(KeySize/8); + EXIT(KeySize/8); END; [TryFunction] - [LineStart(414)] LOCAL PROCEDURE TryEncryptTextBase64@1000000040(VAR UnEncryptedText@1000000012 : Text;VAR EncryptedTextBase64@1000000014 : Text); VAR OStream@1000000002 : OutStream; - TempBlobUnEncrypted@1000000001 : Record TempBlob; - TempBlobEncrypted@1000000000 : Record TempBlob; + 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; + CLEAR(TempBlobUnEncrypted.Blob); + IF UnEncryptedText <> '' THEN BEGIN + TempBlobUnEncrypted.Blob.CREATEOUTSTREAM(OStream); + OStream.WRITETEXT(UnEncryptedText); + END; // Encrypt - if TryEncryptTempBlob(TempBlobUnEncrypted, TempBlobEncrypted) then - begin + 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 ELSE BEGIN + CLEARLASTERROR; + ERROR('Encrypt failed'); + END; END; [TryFunction] - [LineStart(433)] LOCAL PROCEDURE TryDecryptTextBase64@1000000039(VAR EncryptedTextBase64@1000000001 : Text;VAR DecryptedText@1000000000 : Text); VAR IStream@1000000008 : InStream; - TempBlobDecrypted@1000000006 : Record TempBlob; - TempBlobEncrypted@1000000005 : Record TempBlob; - DotNet_Encoding@1000000003 : Codeunit DotNet_Encoding; - DotNet_MemoryStream@1000000004 : Codeunit DotNet_MemoryStream; + 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; + 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 + IF TryDecryptTempBlob(TempBlobEncrypted, TempBlobDecrypted) AND TempBlobDecrypted.Blob.HASVALUE THEN + BEGIN // Create a stream to read from decrypted blob - TempBlobDecrypted.Blob.CreateInStream(IStream); + TempBlobDecrypted.Blob.CREATEINSTREAM(IStream); // Read the decrypted bytes from the blob DotNet_MemoryStream.InitMemoryStream(); @@ -276,60 +257,57 @@ OBJECT Codeunit 50020 Symmetric Encryption Mgt DotNet_Encoding.GetEncoding(DotNetEncoding); DecryptedText := DotNetEncoding.GetString(DotNetMemoryStream.ToArray()); - end else begin - ClearLastError; - Error('Decrypt failed'); - end; + END ELSE BEGIN + CLEARLASTERROR; + ERROR('Decrypt failed'); + END; END; [TryFunction] - [LineStart(463)] - LOCAL PROCEDURE TryEncryptTempBlob@1000000012(VAR UnEncryptedTempBlob@1000000006 : Record TempBlob;VAR EncryptedTempBlob@1000000002 : Record TempBlob); + 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); + UnEncryptedTempBlob.Blob.CREATEINSTREAM(IStream); // Create a stream to write to encrypted tempblob - EncryptedTempBlob.Init(); - EncryptedTempBlob.Blob.CreateOutStream(OStream); + EncryptedTempBlob.INIT(); + EncryptedTempBlob.Blob.CREATEOUTSTREAM(OStream); // Encrypt - if not TryEncryptStream(IStream, OStream) then - begin - ClearLastError; - Error('Encrypt failed'); - end; + IF NOT TryEncryptStream(IStream, OStream) THEN + BEGIN + CLEARLASTERROR; + ERROR('Encrypt failed'); + END; END; [TryFunction] - [LineStart(479)] - LOCAL PROCEDURE TryDecryptTempBlob@1000000007(VAR EncryptedTempBlob@1000000001 : Record TempBlob;VAR DecryptedTempBlob@1000000000 : Record TempBlob); + 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); + EncryptedTempBlob.Blob.CREATEINSTREAM(IStream); // Create a stream to write to decrypted tempblob - Clear(DecryptedTempBlob.Blob); - DecryptedTempBlob.Blob.CreateOutStream(OStream); + CLEAR(DecryptedTempBlob.Blob); + DecryptedTempBlob.Blob.CREATEOUTSTREAM(OStream); // Decrypt - if not TryDecryptStream(IStream, OStream) then - begin - ClearLastError; - Error('Decrypt failed'); - end; + IF NOT TryDecryptStream(IStream, OStream) THEN + BEGIN + CLEARLASTERROR; + ERROR('Decrypt failed'); + END; END; [TryFunction] - [LineStart(495)] LOCAL PROCEDURE TryEncryptStream@1000000035(VAR UnEncryptedStream@1000000001 : InStream;VAR EncryptedStream@1000000000 : OutStream); VAR DotNetSymmetricAlgorithm@1000000021 : DotNet "'mscorlib'.System.Security.Cryptography.SymmetricAlgorithm"; @@ -340,19 +318,19 @@ OBJECT Codeunit 50020 Symmetric Encryption Mgt DotNetStreamReader@1000000016 : DotNet "'mscorlib'.System.IO.StreamReader"; DotNetStreamWriter@1000000015 : DotNet "'mscorlib'.System.IO.StreamWriter"; DotNetArray@1000000013 : DotNet "'mscorlib'.System.Array"; - DotNet_SymmetricAlgorithm@1000000012 : Codeunit DotNet_SymmetricAlgorithm; - DotNet_ICryptoTransform@1000000011 : Codeunit DotNet_ICryptoTransform; - DotNet_CryptoStream@1000000010 : Codeunit DotNet_CryptoStream; - DotNet_Encoding@1000000009 : Codeunit DotNet_Encoding; - DotNet_StreamReader@1000000008 : Codeunit DotNet_StreamReader; - DotNet_StreamWriter@1000000007 : Codeunit DotNet_StreamWriter; - DotNet_StreamEncrypted@1000000005 : Codeunit DotNet_Stream; - DotNet_StreamDecrypted@1000000004 : Codeunit DotNet_Stream; - DotNet_Array@1000000002 : Codeunit DotNet_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 + IF TryCreateSymmetricAlgorithm(DotNet_SymmetricAlgorithm) THEN BEGIN // encoding used for transforms DotNet_Encoding.UTF8; @@ -378,11 +356,11 @@ OBJECT Codeunit 50020 Symmetric Encryption Mgt DotNet_Array.GetArray(DotNetArray); // encrypt - repeat + REPEAT BytesRead := DotNetStreamReader.BaseStream.Read(DotNetArray, 0, DotNetArray.Length); - if BytesRead > 0 then + IF BytesRead > 0 THEN DotNetStreamWriter.BaseStream.Write(DotNetArray, 0, BytesRead); - until BytesRead < 1; + UNTIL BytesRead < 1; DotNetStreamWriter.Flush(); // dispose @@ -391,11 +369,10 @@ OBJECT Codeunit 50020 Symmetric Encryption Mgt DotNetCryptoStream.Dispose(); DotNetICryptoTransform.Dispose(); DotNetSymmetricAlgorithm.Dispose(); - end; + END; END; [TryFunction] - [LineStart(538)] LOCAL PROCEDURE TryDecryptStream@1000000036(VAR EncryptedStream@1000000001 : InStream;VAR DecryptedStream@1000000000 : OutStream); VAR DotNetSymmetricAlgorithm@1000000010 : DotNet "'mscorlib'.System.Security.Cryptography.SymmetricAlgorithm"; @@ -406,19 +383,19 @@ OBJECT Codeunit 50020 Symmetric Encryption Mgt DotNetStreamReader@1000000005 : DotNet "'mscorlib'.System.IO.StreamReader"; DotNetStreamWriter@1000000004 : DotNet "'mscorlib'.System.IO.StreamWriter"; DotNetArray@1000000006 : DotNet "'mscorlib'.System.Array"; - DotNet_SymmetricAlgorithm@1000000002 : Codeunit DotNet_SymmetricAlgorithm; - DotNet_ICryptoTransform@1000000009 : Codeunit DotNet_ICryptoTransform; - DotNet_CryptoStream@1000000011 : Codeunit DotNet_CryptoStream; - DotNet_Encoding@1000000012 : Codeunit DotNet_Encoding; - DotNet_StreamReader@1000000013 : Codeunit DotNet_StreamReader; - DotNet_StreamWriter@1000000014 : Codeunit DotNet_StreamWriter; - DotNet_StreamEncrypted@1000000017 : Codeunit DotNet_Stream; - DotNet_StreamDecrypted@1000000018 : Codeunit DotNet_Stream; - DotNet_Array@1000000015 : Codeunit DotNet_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 + IF TryCreateSymmetricAlgorithm(DotNet_SymmetricAlgorithm) THEN BEGIN // encoding used for transforms DotNet_Encoding.UTF8; @@ -444,11 +421,11 @@ OBJECT Codeunit 50020 Symmetric Encryption Mgt DotNet_Array.GetArray(DotNetArray); // decrypt - repeat + REPEAT BytesRead := DotNetStreamReader.BaseStream.Read(DotNetArray, 0, DotNetArray.Length); - if BytesRead > 0 then + IF BytesRead > 0 THEN DotNetStreamWriter.BaseStream.Write(DotNetArray, 0, BytesRead); - until BytesRead < 1; + UNTIL BytesRead < 1; DotNetStreamWriter.Flush(); DotNetStreamWriter.Close(); @@ -458,46 +435,44 @@ OBJECT Codeunit 50020 Symmetric Encryption Mgt DotNetCryptoStream.Dispose(); DotNetICryptoTransform.Dispose(); DotNetSymmetricAlgorithm.Dispose(); - end; + END; END; [TryFunction] - [LineStart(582)] - LOCAL PROCEDURE TryCreateSymmetricAlgorithm@1000000025(VAR DotNet_SymmetricAlgorithm@1000000005 : Codeunit DotNet_SymmetricAlgorithm); + LOCAL PROCEDURE TryCreateSymmetricAlgorithm@1000000025(VAR DotNet_SymmetricAlgorithm@1000000005 : Codeunit 50010); VAR - DotNet_CipherMode@1000000000 : Codeunit DotNet_CipherMode; - DotNet_PaddingMode@1000000001 : Codeunit DotNet_PaddingMode; + 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); + 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); + IF BlockSize > 0 THEN DotNet_SymmetricAlgorithm.SetBlockSize(BlockSize); DotNet_SymmetricAlgorithm.SetPadding(DotNet_PaddingMode); - if KeySize > 0 then DotNet_SymmetricAlgorithm.SetKeySize(KeySize); + IF KeySize > 0 THEN DotNet_SymmetricAlgorithm.SetKeySize(KeySize); DotNet_SymmetricAlgorithm.SetKey(DotNet_ArrayKey); DotNet_SymmetricAlgorithm.SetIV(DotNet_ArrayIV); END; [TryFunction] - [LineStart(598)] - LOCAL PROCEDURE TrySetCipher@1000000016(VAR TempBlob@1000000000 : Record TempBlob); + LOCAL PROCEDURE TrySetCipher@1000000016(VAR TempBlob@1000000000 : Record 99008535); VAR IStream@1000000001 : InStream; - DotNet_HashAlgorithm@1000000006 : Codeunit DotNet_HashAlgorithm; - DotNet_ArrayHashBytes@1000000012 : Codeunit DotNet_Array; + 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); + TempBlob.Blob.CREATEINSTREAM(IStream); DotNet_HashAlgorithm.Create('SHA384'); DotNet_HashAlgorithm.ComputeHashFromInStream(IStream, DotNet_ArrayHashBytes); diff --git a/Test/COD51010.TXT b/Test/COD51010.TXT index 0bacd67..e5d04a5 100644 --- a/Test/COD51010.TXT +++ b/Test/COD51010.TXT @@ -17,69 +17,63 @@ OBJECT Codeunit 51010 Test_DotNet_SymmetricAlgorithm CODE { VAR - Assert@1001 : Codeunit Assert; + 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] - [LineStart(619)] PROCEDURE TestSymmetricAlgorithmCreateAes@1000000006(); VAR - DotNet_SymmetricAlgorithm@1000000000 : Codeunit DotNet_SymmetricAlgorithm; + 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] - [LineStart(622)] PROCEDURE TestSymmetricAlgorithmCreateDES@1000000014(); VAR - DotNet_SymmetricAlgorithm@1000000000 : Codeunit DotNet_SymmetricAlgorithm; + 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] - [LineStart(625)] PROCEDURE TestSymmetricAlgorithmCreateRC2@1000000015(); VAR - DotNet_SymmetricAlgorithm@1000000000 : Codeunit DotNet_SymmetricAlgorithm; + 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] - [LineStart(628)] PROCEDURE TestSymmetricAlgorithmCreateRijndael@1000000016(); VAR - DotNet_SymmetricAlgorithm@1000000000 : Codeunit DotNet_SymmetricAlgorithm; + 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] - [LineStart(631)] PROCEDURE TestSymmetricAlgorithmCreateTripleDES@1000000017(); VAR - DotNet_SymmetricAlgorithm@1000000000 : Codeunit DotNet_SymmetricAlgorithm; + 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] - [LineStart(634)] PROCEDURE TestSetGetMode@1000000008(); VAR - DotNet_SymmetricAlgorithm@1000000001 : Codeunit DotNet_SymmetricAlgorithm; - DotNet_CipherMode@1000000002 : Codeunit DotNet_CipherMode; - DotNet_CipherMode2@1000000003 : Codeunit DotNet_CipherMode; + DotNet_SymmetricAlgorithm@1000000001 : Codeunit 50010; + DotNet_CipherMode@1000000002 : Codeunit 50015; + DotNet_CipherMode2@1000000003 : Codeunit 50015; BEGIN DotNet_SymmetricAlgorithm.Create('Aes'); DotNet_CipherMode.CBC(); @@ -89,12 +83,11 @@ OBJECT Codeunit 51010 Test_DotNet_SymmetricAlgorithm END; [Test] - [LineStart(641)] PROCEDURE TestSetGetPadding@1000000007(); VAR - DotNet_SymmetricAlgorithm@1000000000 : Codeunit DotNet_SymmetricAlgorithm; - DotNet_PaddingMode@1000000001 : Codeunit DotNet_PaddingMode; - DotNet_PaddingMode2@1000000002 : Codeunit DotNet_PaddingMode; + DotNet_SymmetricAlgorithm@1000000000 : Codeunit 50010; + DotNet_PaddingMode@1000000001 : Codeunit 50016; + DotNet_PaddingMode2@1000000002 : Codeunit 50016; BEGIN DotNet_SymmetricAlgorithm.Create('Aes'); DotNet_PaddingMode.Zeros(); @@ -104,10 +97,9 @@ OBJECT Codeunit 51010 Test_DotNet_SymmetricAlgorithm END; [Test] - [LineStart(648)] PROCEDURE TestSetGetBlockSize@1000000012(); VAR - DotNet_SymmetricAlgorithm@1000000000 : Codeunit DotNet_SymmetricAlgorithm; + DotNet_SymmetricAlgorithm@1000000000 : Codeunit 50010; BlockSize@1000000001 : Integer; BEGIN DotNet_SymmetricAlgorithm.Create('Aes'); @@ -117,10 +109,9 @@ OBJECT Codeunit 51010 Test_DotNet_SymmetricAlgorithm END; [Test] - [LineStart(654)] PROCEDURE TestSetGetKeySize@1000000009(); VAR - DotNet_SymmetricAlgorithm@1000000000 : Codeunit DotNet_SymmetricAlgorithm; + DotNet_SymmetricAlgorithm@1000000000 : Codeunit 50010; KeySize@1000000001 : Integer; BEGIN DotNet_SymmetricAlgorithm.Create('Aes'); @@ -130,10 +121,9 @@ OBJECT Codeunit 51010 Test_DotNet_SymmetricAlgorithm END; [Test] - [LineStart(660)] PROCEDURE TestSetGetFeedbackSize@1000000013(); VAR - DotNet_SymmetricAlgorithm@1000000000 : Codeunit DotNet_SymmetricAlgorithm; + DotNet_SymmetricAlgorithm@1000000000 : Codeunit 50010; FeedbackSize@1000000001 : Integer; BEGIN DotNet_SymmetricAlgorithm.Create('Aes'); @@ -144,23 +134,22 @@ OBJECT Codeunit 51010 Test_DotNet_SymmetricAlgorithm END; [Test] - [LineStart(667)] PROCEDURE TestSetGetKey@1000000010(); VAR - DotNet_SymmetricAlgorithm@1000000000 : Codeunit DotNet_SymmetricAlgorithm; - DotNet_Array@1000000001 : Codeunit DotNet_Array; - DotNet_ArrayKey@1000000002 : Codeunit DotNet_Array; + 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 + 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 + FOR Index := 0 TO DotNet_Array.Length-1 DO Assert.AreEqual( DotNet_Array.GetValueAsInteger(Index), DotNet_ArrayKey.GetValueAsInteger(Index), @@ -168,82 +157,76 @@ OBJECT Codeunit 51010 Test_DotNet_SymmetricAlgorithm END; [Test] - [LineStart(682)] PROCEDURE TestSetGetIV@1000000011(); VAR - DotNet_SymmetricAlgorithm@1000000000 : Codeunit DotNet_SymmetricAlgorithm; - DotNet_Array@1000000003 : Codeunit DotNet_Array; - DotNet_ArrayIV@1000000002 : Codeunit DotNet_Array; + 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 + 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 + 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; - [LineStart(697)] PROCEDURE SymmetricAlgorithmCreateAes@1000000000(); VAR - DotNet_SymmetricAlgorithm@1000000000 : Codeunit DotNet_SymmetricAlgorithm; + 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'); + Assert.IsFalse(ISNULL(DotNetSymmetricAlgorithm), 'SymmetricAlgorithm Create AES failed'); END; - [LineStart(702)] PROCEDURE SymmetricAlgorithmCreateDES@1000000003(); VAR - DotNet_SymmetricAlgorithm@1000000000 : Codeunit DotNet_SymmetricAlgorithm; + 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'); + Assert.IsFalse(ISNULL(DotNetSymmetricAlgorithm), 'SymmetricAlgorithm Create DES failed'); END; - [LineStart(707)] PROCEDURE SymmetricAlgorithmCreateRC2@1000000001(); VAR - DotNet_SymmetricAlgorithm@1000000000 : Codeunit DotNet_SymmetricAlgorithm; + 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'); + Assert.IsFalse(ISNULL(DotNetSymmetricAlgorithm), 'SymmetricAlgorithm Create RC2 failed'); END; - [LineStart(712)] PROCEDURE SymmetricAlgorithmCreateRijndael@1000000002(); VAR - DotNet_SymmetricAlgorithm@1000000000 : Codeunit DotNet_SymmetricAlgorithm; + 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'); + Assert.IsFalse(ISNULL(DotNetSymmetricAlgorithm), 'SymmetricAlgorithm Create Rijndael failed'); END; - [LineStart(717)] PROCEDURE SymmetricAlgorithmCreateTripleDES@1000000004(); VAR - DotNet_SymmetricAlgorithm@1000000000 : Codeunit DotNet_SymmetricAlgorithm; + 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'); + Assert.IsFalse(ISNULL(DotNetSymmetricAlgorithm), 'SymmetricAlgorithm Create TripleDES failed'); END; BEGIN diff --git a/Test/COD51012.TXT b/Test/COD51012.TXT index 605d85a..c22223d 100644 --- a/Test/COD51012.TXT +++ b/Test/COD51012.TXT @@ -17,12 +17,11 @@ OBJECT Codeunit 51012 Test_DotNet_HashAlgorithm CODE { VAR - Assert@1001 : Codeunit Assert; - DotNet_HashAlgorithm@1002 : Codeunit DotNet_StreamWriter; - DotNet_Array@1000000001 : Codeunit DotNet_Array; + Assert@1001 : Codeunit 130000; + DotNet_HashAlgorithm@1002 : Codeunit 3025; + DotNet_Array@1000000001 : Codeunit 3000; [Test] - [LineStart(724)] PROCEDURE TestGenerateFromText@1(); VAR SampleText@1000000000 : Text; @@ -34,71 +33,69 @@ OBJECT Codeunit 51012 Test_DotNet_HashAlgorithm // SHA1 ExpectedText := '4045ed3c779e3b27760e4da357279508a8452dcb'; HashText := GenerateFromText('SHA1', SampleText); - Assert.AreEqual(ExpectedText, LowerCase(HashText), 'SHA1 Hashes differ, failed'); + 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'); + 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'); + 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'); + 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'); + Assert.AreEqual(ExpectedText, LOWERCASE(HashText), 'SHA512 Hashes differ, failed'); END; [Test] - [LineStart(748)] PROCEDURE TestGenerateFromStream@1000000001(); VAR SampleText@1000000002 : Text; ExpectedText@1000000001 : Text; HashText@1000000000 : Text; IStream@1000000003 : InStream; - TempBlob@1000000004 : TEMPORARY Record TempBlob; + TempBlob@1000000004 : TEMPORARY Record 99008535; BEGIN SampleText := 'Lorem ipsum dolor sit amet, consectetur adipiscing elit'; - Clear(TempBlob.Blob); + CLEAR(TempBlob.Blob); TempBlob.WriteAsText(SampleText, TEXTENCODING::UTF8); // SHA1 ExpectedText := '4045ed3c779e3b27760e4da357279508a8452dcb'; - TempBlob.Blob.CreateInStream(IStream); + TempBlob.Blob.CREATEINSTREAM(IStream); HashText := GenerateFromStream('SHA1', IStream); - Assert.AreEqual(ExpectedText, LowerCase(HashText), 'SHA1 Hashes differ, failed'); + Assert.AreEqual(ExpectedText, LOWERCASE(HashText), 'SHA1 Hashes differ, failed'); // MD5 ExpectedText := 'fc10a08df7fafa3871166646609e1c95'; - TempBlob.Blob.CreateInStream(IStream); + TempBlob.Blob.CREATEINSTREAM(IStream); HashText := GenerateFromStream('MD5', IStream); - Assert.AreEqual(ExpectedText, LowerCase(HashText), 'MD5 Hashes differ, failed'); + Assert.AreEqual(ExpectedText, LOWERCASE(HashText), 'MD5 Hashes differ, failed'); // SHA256 ExpectedText := '07fe4d4a25718241af145a93f890eb5469052e251d199d173bd3bd50c3bb4da2'; - TempBlob.Blob.CreateInStream(IStream); + TempBlob.Blob.CREATEINSTREAM(IStream); HashText := GenerateFromStream('SHA256', IStream); - Assert.AreEqual(ExpectedText, LowerCase(HashText), 'SHA256 Hashes differ, failed'); + Assert.AreEqual(ExpectedText, LOWERCASE(HashText), 'SHA256 Hashes differ, failed'); // SHA384 ExpectedText := '845524c97cf0606df6ce8a2e5a7e35701a9ed12685a366eabef599648dd8ba33c1e176e96efe51320a40a6b65c18c4cf'; - TempBlob.Blob.CreateInStream(IStream); + TempBlob.Blob.CREATEINSTREAM(IStream); HashText := GenerateFromStream('SHA384', IStream); - Assert.AreEqual(ExpectedText, LowerCase(HashText), 'SHA384 Hashes differ, failed'); + Assert.AreEqual(ExpectedText, LOWERCASE(HashText), 'SHA384 Hashes differ, failed'); // SHA512 ExpectedText := 'd3b3d69ccc163089f91d42ebef0f01dd70ec40deb76a9da5ba63ef5b39601b41a34b04f8236ce9e59a150241716a5e2da9f1bdcc2734d4d7fcd8e69df36022f0'; - TempBlob.Blob.CreateInStream(IStream); + TempBlob.Blob.CREATEINSTREAM(IStream); HashText := GenerateFromStream('SHA512', IStream); - Assert.AreEqual(ExpectedText, LowerCase(HashText), 'SHA512 Hashes differ, failed'); + Assert.AreEqual(ExpectedText, LOWERCASE(HashText), 'SHA512 Hashes differ, failed'); END; - [LineStart(780)] LOCAL PROCEDURE GenerateFromText@1000000002(HashMode@1000000000 : Text;TextToHash@1000000003 : Text) : Text; VAR - DotNet_HashAlgorithm@1000000002 : Codeunit DotNet_HashAlgorithm; + DotNet_HashAlgorithm@1000000002 : Codeunit 50012; DotNetBitConverter@1000000004 : DotNet "'mscorlib'.System.BitConverter"; DotNetArray@1000000005 : DotNet "'mscorlib'.System.Array"; DotNetString@1000000001 : DotNet "'mscorlib'.System.String"; @@ -107,13 +104,12 @@ OBJECT Codeunit 51012 Test_DotNet_HashAlgorithm DotNet_HashAlgorithm.ComputeHashFromText(TextToHash, DotNet_Array); DotNet_Array.GetArray(DotNetArray); DotNetString := DotNetBitConverter.ToString(DotNetArray); - exit(DotNetString.Replace('-','')); + EXIT(DotNetString.Replace('-','')); END; - [LineStart(787)] LOCAL PROCEDURE GenerateFromStream@1000000003(HashMode@1000000001 : Text;InputStream@1000000000 : InStream) : Text; VAR - DotNet_HashAlgorithm@1000000003 : Codeunit DotNet_HashAlgorithm; + DotNet_HashAlgorithm@1000000003 : Codeunit 50012; DotNetBitConverter@1000000004 : DotNet "'mscorlib'.System.BitConverter"; DotNetArray@1000000002 : DotNet "'mscorlib'.System.Array"; DotNetString@1000000005 : DotNet "'mscorlib'.System.String"; @@ -122,7 +118,7 @@ OBJECT Codeunit 51012 Test_DotNet_HashAlgorithm DotNet_HashAlgorithm.ComputeHashFromInStream(InputStream, DotNet_Array); DotNet_Array.GetArray(DotNetArray); DotNetString := DotNetBitConverter.ToString(DotNetArray); - exit(DotNetString.Replace('-','')); + EXIT(DotNetString.Replace('-','')); END; BEGIN diff --git a/Test/COD51013.TXT b/Test/COD51013.TXT index 33078fb..830362a 100644 --- a/Test/COD51013.TXT +++ b/Test/COD51013.TXT @@ -17,14 +17,13 @@ OBJECT Codeunit 51013 Test_DotNet_ICryptoTransform CODE { VAR - Assert@1001 : Codeunit Assert; + Assert@1001 : Codeunit 130000; [Test] - [LineStart(796)] PROCEDURE TestGetSet@1000000000(); VAR - DotNet_SymmetricAlgorithm@1000000001 : Codeunit DotNet_SymmetricAlgorithm; - DotNet_ICryptoTransform@1000000000 : Codeunit DotNet_ICryptoTransform; + 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"; @@ -41,7 +40,7 @@ OBJECT Codeunit 51013 Test_DotNet_ICryptoTransform // [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'); + Assert.IsFalse(ISNULL(DotNetICryptoTransform2), 'ICryptoTransform Get/Set failed'); END; BEGIN diff --git a/Test/COD51014.TXT b/Test/COD51014.TXT index c581ef2..b2a9c6e 100644 --- a/Test/COD51014.TXT +++ b/Test/COD51014.TXT @@ -17,21 +17,20 @@ OBJECT Codeunit 51014 Test_DotNet_CryptoStream CODE { VAR - Assert@1001 : Codeunit Assert; + Assert@1001 : Codeunit 130000; [Test] - [LineStart(812)] PROCEDURE TestCryptoOutStream@1000000000(); VAR - DotNet_SymmetricAlgorithm@1000000001 : Codeunit DotNet_SymmetricAlgorithm; - DotNet_ICryptoTransform@1000000000 : Codeunit DotNet_ICryptoTransform; - DotNet_CryptoStream@1000000005 : Codeunit DotNet_CryptoStream; - TempBlob@1000000007 : TEMPORARY Record TempBlob; + 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); + 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 @@ -43,32 +42,31 @@ OBJECT Codeunit 51014 Test_DotNet_CryptoStream END; [Test] - [LineStart(825)] PROCEDURE TestCryptoInStream@1000000001(); VAR - DotNet_SymmetricAlgorithm@1000000001 : Codeunit DotNet_SymmetricAlgorithm; - DotNet_ICryptoTransform@1000000000 : Codeunit DotNet_ICryptoTransform; - DotNet_CryptoStream@1000000005 : Codeunit DotNet_CryptoStream; - DotNet_Array@1000000010 : Codeunit DotNet_Array; - TempBlob@1000000004 : TEMPORARY Record TempBlob; + 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); + CLEAR(TempBlob.Blob); TempBlob.WriteAsText('Lorem ipsum dolor', TEXTENCODING::UTF8); - TempBlob.Blob.CreateInStream(IStream); + 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 + 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 + FOR Index := 0 TO DotNet_Array.Length-1 DO DotNet_Array.SetByteValue(Index, Index); DotNet_SymmetricAlgorithm.SetIV(DotNet_Array); // [WHEN] Decryptor transform is created diff --git a/Test/COD51020.TXT b/Test/COD51020.TXT index ab7fd96..48451ea 100644 --- a/Test/COD51020.TXT +++ b/Test/COD51020.TXT @@ -16,35 +16,32 @@ OBJECT Codeunit 51020 Test_Symmetric_Encryption_Mgt CODE { VAR - Assert@1000000005 : Codeunit Assert; - LibraryUtility@1000000001 : Codeunit "Library - Utility"; - LibraryRandom@1000000000 : Codeunit "Library - Random"; + 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'; - [LineStart(852)] 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); + EXIT(DotNetString.Compare(Left, Right) = 0); END; - [LineStart(855)] - LOCAL PROCEDURE EncryptDecryptText@1000000007(VAR SymmetricEncryption@1000000003 : Codeunit "Symmetric Encryption Mgt";VAR TextClear@1000000006 : Text;VAR TextEncrypted@1000000007 : Text;VAR TextDecrypted@1000000008 : Text); + 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] - [LineStart(859)] PROCEDURE AES_256_CBC_PKCS7_EncryptDecrypt@1000000004(); VAR - SymmetricEncryption@1000000003 : Codeunit "Symmetric Encryption Mgt"; + SymmetricEncryption@1000000003 : Codeunit 50020; TextCipher@1000000004 : Text; TextToEncrypt@1000000002 : Text; TextEncrypted@1000000001 : Text; @@ -59,15 +56,14 @@ OBJECT Codeunit 51020 Test_Symmetric_Encryption_Mgt END; [Test] - [LineStart(867)] PROCEDURE AES_256_CBC_PKCS7_SetCipherFromBlob_EncryptDecrypt@1000000002(); VAR - SymmetricEncryption@1000000007 : Codeunit "Symmetric Encryption Mgt"; + SymmetricEncryption@1000000007 : Codeunit 50020; TextToEncrypt@1000000008 : Text; TextDecrypted@1000000009 : Text; TextEncrypted@1000000014 : Text; TextCipher@1000000011 : Text; - TempBlobCipher@1000000000 : Record TempBlob; + TempBlobCipher@1000000000 : Record 99008535; BEGIN TextCipher := LibraryUtility.GenerateRandomText(LibraryRandom.RandIntInRange(1,64)); TextToEncrypt := LibraryUtility.GenerateRandomText(100000); // to stress the read buffer @@ -82,18 +78,17 @@ OBJECT Codeunit 51020 Test_Symmetric_Encryption_Mgt END; [Test] - [LineStart(879)] PROCEDURE AES_256_CBC_PKCS7_SetKeyIV_EncryptDecrypt@1000000018(); VAR - SymmetricEncryption@1000000007 : Codeunit "Symmetric Encryption Mgt"; + 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 DotNet_Array; - DotNet_ArrayIV@1000000004 : Codeunit DotNet_Array; + 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'; @@ -122,10 +117,9 @@ OBJECT Codeunit 51020 Test_Symmetric_Encryption_Mgt END; [Test] - [LineStart(904)] PROCEDURE AES_192_CBC_PKCS7_EncryptDecrypt@1000000027(); VAR - SymmetricEncryption@1000000003 : Codeunit "Symmetric Encryption Mgt"; + SymmetricEncryption@1000000003 : Codeunit 50020; TextCipher@1000000004 : Text; TextToEncrypt@1000000002 : Text; TextEncrypted@1000000001 : Text; @@ -141,10 +135,9 @@ OBJECT Codeunit 51020 Test_Symmetric_Encryption_Mgt END; [Test] - [LineStart(913)] PROCEDURE AES_128_CBC_PKCS7_EncryptDecrypt@1000000005(); VAR - SymmetricEncryption@1000000003 : Codeunit "Symmetric Encryption Mgt"; + SymmetricEncryption@1000000003 : Codeunit 50020; TextCipher@1000000004 : Text; TextToEncrypt@1000000002 : Text; TextEncrypted@1000000001 : Text; @@ -160,15 +153,14 @@ OBJECT Codeunit 51020 Test_Symmetric_Encryption_Mgt END; [Test] - [LineStart(922)] PROCEDURE AES_256_CFB_PKCS7_EncryptDecrypt@1000000010(); VAR - SymmetricEncryption@1000000003 : Codeunit "Symmetric Encryption Mgt"; + SymmetricEncryption@1000000003 : Codeunit 50020; TextCipher@1000000004 : Text; TextToEncrypt@1000000002 : Text; TextEncrypted@1000000001 : Text; TextDecrypted@1000000000 : Text; - DotNet_CipherMode@1000000005 : Codeunit DotNet_CipherMode; + DotNet_CipherMode@1000000005 : Codeunit 50015; BEGIN TextCipher := LibraryUtility.GenerateRandomText(LibraryRandom.RandIntInRange(1,64)); TextToEncrypt := LibraryUtility.GenerateRandomText(1); @@ -181,10 +173,9 @@ OBJECT Codeunit 51020 Test_Symmetric_Encryption_Mgt END; [Test] - [LineStart(932)] PROCEDURE AES_256_CTS_PKCS7_EncryptDecrypt@1000000014(); VAR - SymmetricEncryption@1000000003 : Codeunit "Symmetric Encryption Mgt"; + SymmetricEncryption@1000000003 : Codeunit 50020; TextCipher@1000000004 : Text; TextToEncrypt@1000000002 : Text; TextEncrypted@1000000001 : Text; @@ -194,15 +185,14 @@ OBJECT Codeunit 51020 Test_Symmetric_Encryption_Mgt END; [Test] - [LineStart(935)] PROCEDURE AES_256_ECB_PKCS7_EncryptDecrypt@1000000012(); VAR - SymmetricEncryption@1000000003 : Codeunit "Symmetric Encryption Mgt"; + SymmetricEncryption@1000000003 : Codeunit 50020; TextCipher@1000000004 : Text; TextToEncrypt@1000000002 : Text; TextEncrypted@1000000001 : Text; TextDecrypted@1000000000 : Text; - DotNet_CipherMode@1000000005 : Codeunit DotNet_CipherMode; + DotNet_CipherMode@1000000005 : Codeunit 50015; BEGIN TextCipher := LibraryUtility.GenerateRandomText(LibraryRandom.RandIntInRange(1,64)); TextToEncrypt := LibraryUtility.GenerateRandomText(LibraryRandom.RandIntInRange(1,1024)); @@ -215,10 +205,9 @@ OBJECT Codeunit 51020 Test_Symmetric_Encryption_Mgt END; [Test] - [LineStart(945)] PROCEDURE AES_256_OFB_PKCS7_EncryptDecrypt@1000000015(); VAR - SymmetricEncryption@1000000003 : Codeunit "Symmetric Encryption Mgt"; + SymmetricEncryption@1000000003 : Codeunit 50020; TextCipher@1000000004 : Text; TextToEncrypt@1000000002 : Text; TextEncrypted@1000000001 : Text; @@ -228,15 +217,14 @@ OBJECT Codeunit 51020 Test_Symmetric_Encryption_Mgt END; [Test] - [LineStart(948)] PROCEDURE AES_256_CBC_ANSIX923_EncryptDecrypt@1000000008(); VAR - SymmetricEncryption@1000000007 : Codeunit "Symmetric Encryption Mgt"; + SymmetricEncryption@1000000007 : Codeunit 50020; TextCipher@1000000001 : Text; TextToEncrypt@1000000008 : Text; TextEncrypted@1000000000 : Text; TextDecrypted@1000000009 : Text; - DotNet_PaddingMode@1000000002 : Codeunit DotNet_PaddingMode; + DotNet_PaddingMode@1000000002 : Codeunit 50016; BEGIN TextCipher := LibraryUtility.GenerateRandomText(LibraryRandom.RandIntInRange(1,64)); TextToEncrypt := LibraryUtility.GenerateRandomText(LibraryRandom.RandIntInRange(1,1024)); @@ -249,15 +237,14 @@ OBJECT Codeunit 51020 Test_Symmetric_Encryption_Mgt END; [Test] - [LineStart(958)] PROCEDURE AES_256_CBC_ISO10126_EncryptDecrypt@1000000011(); VAR - SymmetricEncryption@1000000007 : Codeunit "Symmetric Encryption Mgt"; + SymmetricEncryption@1000000007 : Codeunit 50020; TextCipher@1000000001 : Text; TextToEncrypt@1000000008 : Text; TextEncrypted@1000000000 : Text; TextDecrypted@1000000009 : Text; - DotNet_PaddingMode@1000000002 : Codeunit DotNet_PaddingMode; + DotNet_PaddingMode@1000000002 : Codeunit 50016; BEGIN TextCipher := LibraryUtility.GenerateRandomText(LibraryRandom.RandIntInRange(1,64)); TextToEncrypt := LibraryUtility.GenerateRandomText(LibraryRandom.RandIntInRange(1,1024)); @@ -270,15 +257,14 @@ OBJECT Codeunit 51020 Test_Symmetric_Encryption_Mgt END; [Test] - [LineStart(968)] PROCEDURE AES_256_CBC_Zeros_EncryptDecrypt@1000000013(); VAR - SymmetricEncryption@1000000007 : Codeunit "Symmetric Encryption Mgt"; + SymmetricEncryption@1000000007 : Codeunit 50020; TextCipher@1000000001 : Text; TextToEncrypt@1000000008 : Text; TextEncrypted@1000000000 : Text; TextDecrypted@1000000009 : Text; - DotNet_PaddingMode@1000000002 : Codeunit DotNet_PaddingMode; + DotNet_PaddingMode@1000000002 : Codeunit 50016; BEGIN TextCipher := LibraryUtility.GenerateRandomText(LibraryRandom.RandIntInRange(1,64)); TextToEncrypt := LibraryUtility.GenerateRandomText(LibraryRandom.RandIntInRange(1,1024)); @@ -291,10 +277,9 @@ OBJECT Codeunit 51020 Test_Symmetric_Encryption_Mgt END; [Test] - [LineStart(978)] PROCEDURE AES_256_CBC_PKCS7_EncryptStringFail@1000000016(); VAR - SymmetricEncryption@1000000003 : Codeunit "Symmetric Encryption Mgt"; + SymmetricEncryption@1000000003 : Codeunit 50020; TextCipher@1000000004 : Text; TextToEncrypt@1000000002 : Text; TextEncrypted@1000000001 : Text; @@ -306,10 +291,9 @@ OBJECT Codeunit 51020 Test_Symmetric_Encryption_Mgt END; [Test] - [LineStart(983)] PROCEDURE AES_256_CBC_PKCS7_DecryptStringFail@1000000017(); VAR - SymmetricEncryption@1000000003 : Codeunit "Symmetric Encryption Mgt"; + SymmetricEncryption@1000000003 : Codeunit 50020; TextCipher@1000000004 : Text; TextToEncrypt@1000000001 : Text; TextToDecrypt@1000000002 : Text; @@ -324,16 +308,15 @@ OBJECT Codeunit 51020 Test_Symmetric_Encryption_Mgt Assert.IsTrue(SymmetricEncryption.EncryptTextBase64(TextToEncrypt, TextEncrypted), E_EXPECTED_SUCCESS); // Mangle encrypted string - TextEncrypted[StrLen(TextEncrypted)-2] := '_'; - TextEncrypted[StrLen(TextEncrypted)-1] := '_'; + TextEncrypted[STRLEN(TextEncrypted)-2] := '_'; + TextEncrypted[STRLEN(TextEncrypted)-1] := '_'; Assert.IsFalse(SymmetricEncryption.DecryptTextBase64(TextEncrypted, TextDecrypted), E_EXPECTED_FAILURE); END; [Test] - [LineStart(996)] PROCEDURE DES_EncryptDecrypt@1000000006(); VAR - SymmetricEncryption@1000000003 : Codeunit "Symmetric Encryption Mgt"; + SymmetricEncryption@1000000003 : Codeunit 50020; TextCipher@1000000004 : Text; TextToEncrypt@1000000002 : Text; TextEncrypted@1000000001 : Text; @@ -349,10 +332,9 @@ OBJECT Codeunit 51020 Test_Symmetric_Encryption_Mgt END; [Test] - [LineStart(1005)] PROCEDURE RC2_EncryptDecrypt@1000000001(); VAR - SymmetricEncryption@1000000003 : Codeunit "Symmetric Encryption Mgt"; + SymmetricEncryption@1000000003 : Codeunit 50020; TextCipher@1000000004 : Text; TextToEncrypt@1000000002 : Text; TextEncrypted@1000000001 : Text; @@ -368,10 +350,9 @@ OBJECT Codeunit 51020 Test_Symmetric_Encryption_Mgt END; [Test] - [LineStart(1014)] PROCEDURE Rijndael_EncryptDecrypt@1000000003(); VAR - SymmetricEncryption@1000000003 : Codeunit "Symmetric Encryption Mgt"; + SymmetricEncryption@1000000003 : Codeunit 50020; TextCipher@1000000004 : Text; TextToEncrypt@1000000002 : Text; TextEncrypted@1000000001 : Text; @@ -387,10 +368,9 @@ OBJECT Codeunit 51020 Test_Symmetric_Encryption_Mgt END; [Test] - [LineStart(1023)] PROCEDURE TripleDES_EncryptDecrypt@1000000009(); VAR - SymmetricEncryption@1000000003 : Codeunit "Symmetric Encryption Mgt"; + SymmetricEncryption@1000000003 : Codeunit 50020; TextCipher@1000000004 : Text; TextToEncrypt@1000000002 : Text; TextEncrypted@1000000001 : Text;