mheyman / isopoh.cryptography.argon2 Goto Github PK

System.TypeInitializationException: The type initializer for 'Isopoh.Cryptography.SecureArray.SecureArray' threw an exception. ---> System.NotSupportedException: No SecureArray.DefaultCall support for current operating system (whatever that is, maybe "Microsoft Windows NT 10.0.19041.0", I think I know Windows, Linux, OSX, and web - and maybe iOS...). You  don't have to use the default SecureArrayCall - you can pass in a version of the calls that work for your operating system.
  at Isopoh.Cryptography.SecureArray.SecureArray.get_DefaultCall () [0x00000] in <00000000000000000000000000000000>:0 
  at Isopoh.Cryptography.SecureArray.SecureArray..cctor () [0x00000] in <00000000000000000000000000000000>:0 
  at Isopoh.Cryptography.SecureArray.SecureArray`1[T]..ctor (System.Int32 size, Isopoh.Cryptography.SecureArray.SecureArrayType type, Isopoh.Cryptography.SecureArray.SecureArrayCall call) [0x00000] in <00000000000000000000000000000000>:0 
  at Isopoh.Cryptography.SecureArray.SecureArray`1[T].Best (System.Int32 size, Isopoh.Cryptography.SecureArray.SecureArrayCall secureArrayCall) [0x00000] in <00000000000000000000000000000000>:0 
  at Isopoh.Cryptography.Argon2.Argon2.Hash (System.String password, System.String secret, System.Int32 timeCost, System.Int32 memoryCost, System.Int32 parallelism, Isopoh.Cryptography.Argon2.Argon2Type type, System.Int32 hashLength, Isopoh.Cryptography.SecureArray.SecureArrayCall secureArrayCall) [0x00000] in <00000000000000000000000000000000>:0 
  at Isopoh.Cryptography.Argon2.Argon2.Hash (System.String password, System.Int32 timeCost, System.Int32 memoryCost, System.Int32 parallelism, Isopoh.Cryptography.Argon2.Argon2Type type, System.Int32 hashLength, Isopoh.Cryptography.SecureArray.SecureArrayCall secureArrayCall) [0x00000] in <00000000000000000000000000000000>:0 
  at StoredCreds.PrepareCredentialsForStorage (Credentials credentials) [0x00000] in <00000000000000000000000000000000>:0 
  at UserSelectionMode.Activate (NavigationParameters navigationParameters) [0x00000] in <00000000000000000000000000000000>:0 

    private void DoForms()
    {
        Form1 form1 = new Form1();
        var pb = new PictureBox();
        pb.Image = global::TPCamera.Properties.Resources.instacam;
        pb.SizeMode = PictureBoxSizeMode.AutoSize;
        form1.Controls.Add(pb);
        form1.Show();

        Form2 form2 = new Form2();
        pb = new PictureBox();
        pb.Image = global::TPCamera.Properties.Resources.instacam;
        pb.SizeMode = PictureBoxSizeMode.AutoSize;
        form2.Controls.Add(pb);
        form2.Show();

        var screenSaver = frmScreenSaver.CreateInstance();
        screenSaver.Show();

        bgw3 = new BackgroundWorker();
        bgw3.WorkerReportsProgress = true;
        bgw3.DoWork += new DoWorkEventHandler(form1.bgw1_DoWork);
        bgw3.ProgressChanged += form1.bgw1_ProgressChanged;
        bgw3.RunWorkerCompleted += new System.ComponentModel.RunWorkerCompletedEventHandler(form1.bgw1_RunWorkerCompleted);
        bgw3.RunWorkerAsync(20000);

        bgw4 = new BackgroundWorker();
        bgw4.WorkerReportsProgress = true;
        bgw4.DoWork += new DoWorkEventHandler(this.bgw2_DoWork);
        bgw4.ProgressChanged += form2.bgw2_ProgressChanged;
        bgw4.RunWorkerCompleted += new System.ComponentModel.RunWorkerCompletedEventHandler(form2.bgw2_RunWorkerCompleted);
        bgw4.RunWorkerAsync(10000);
    }

       `var config = new Argon2Config();
        var password = txtPassword.Text.Trim();
        var passwordHash = txtPassword.Text.Trim().Encrypt(out config);`

public static partial class Extenders
{
    public static string Encrypt(this string password, out Argon2Config config)
    {
        config = null;
        if (string.IsNullOrEmpty(password))
            return string.Empty;

        byte[] passwordBytes = Encoding.UTF8.GetBytes(password);
        byte[] salt = Encoding.UTF8.GetBytes("???????????????");
        byte[] secret = Encoding.UTF8.GetBytes("???????????????");
        byte[] associatedData = Encoding.UTF8.GetBytes("???????????????");

        //var _rng = RandomNumberGenerator.Create();
        //_rng.GetBytes(salt);
        //_rng.GetBytes(secret);
        //_rng.GetBytes(associatedData);

        config = new Argon2Config
        {
            Type = Argon2Type.DataIndependentAddressing,
            Version = Argon2Version.Nineteen,
            TimeCost = 10,
            MemoryCost = 32768,
            Lanes = 5,
            Threads = Environment.ProcessorCount,
            Password = passwordBytes,
            Salt = salt, // >= 8 bytes if not null
            Secret = secret,
            AssociatedData = associatedData,
            HashLength = 20 // >= 4
        };
        var argon2A = new Argon2(config);
        string hashString;
        using (SecureArray<byte> hashA = argon2A.Hash()) //===> this line of code stops GIFs
        {
            hashString = config.EncodeString(hashA.Buffer);
        }
         
        return hashString;
    }
}

 echo "123" | argon2 12345678
Type:		Argon2i
Iterations:	3
Memory:		4096 KiB
Parallelism:	1
Hash:		ae1aaf1a29bbfe3f7d7bdd66c9d6478862b4d478d029a57f83631a9904f04ee7
Encoded:	$argon2i$v=19$m=4096,t=3,p=1$MTIzNDU2Nzg$rhqvGim7/j99e91mydZHiGK01HjQKaV/g2MamQTwTuc
0.019 seconds
Verification ok

aptitude show argon2
Package: argon2                          
Version: 0~20171227-0.2
State: installed
Automatically installed: no
Multi-Arch: foreign
Priority: optional
Section: libs
Maintainer: Luca Bruno <[email protected]>
Architecture: amd64
Uncompressed Size: 65.5 k
Depends: libc6 (>= 2.14)
Description: memory-hard hashing function - utility
 Argon2 is a password-hashing function that can be used to hash passwords for credential storage, key derivation, or other applications. 
 
 There are two main versions of Argon2: Argon2i and Argon2d. Argon2i is the safest against side-channel attacks, while Argon2d provides the highest resistance
 against GPU cracking attacks. 
 
 Argon2i and Argon2d are parametrized by: 
 * A time cost, which defines the amount of computation realized and therefore the execution time, given in number of iterations 
 * A memory cost, which defines the memory usage, given in kibibytes 
 * A parallelism degree, which defines the number of parallel threads 
   
 This package contains the argon2 tool for hashing data on the command-line.
Homepage: https://github.com/P-H-C/phc-winner-argon2
Tags: role::shared-lib

<PropertyGroup>
    <TargetFramework>netcoreapp3.1</TargetFramework>
</PropertyGroup>
<ItemGroup>
    <PackageReference Include="Isopoh.Cryptography.Argon2" Version="1.1.10" />
  </ItemGroup>

System.TypeInitializationException: 'A type initializer threw an exception. To determine which type, inspect the InnerException's StackTrace property.'
Inner exception:
TypeLoadException: Unresolved P/Invoke method 'libSystem!OsxMemset' from this method. Please look for this method in build warnings for more details. 

   at System.Runtime.CompilerServices.ClassConstructorRunner.EnsureClassConstructorRun(StaticClassConstructionContext* pContext) in f:\dd\ndp\fxcore\CoreRT\src\System.Private.CoreLib\src\System\Runtime\CompilerServices\ClassConstructorRunner.cs:line 114
   at System.Runtime.CompilerServices.ClassConstructorRunner.CheckStaticClassConstruction(Void* returnValue, StaticClassConstructionContext* pContext) in f:\dd\ndp\fxcore\CoreRT\src\System.Private.CoreLib\src\System\Runtime\CompilerServices\ClassConstructorRunner.cs:line 37
   at Isopoh.Cryptography.SecureArray.SecureArray..ctor(SecureArrayCall call)
   at Isopoh.Cryptography.SecureArray.SecureArray`1..ctor(Int32 size, SecureArrayType type, SecureArrayCall call)
   at Isopoh.Cryptography.SecureArray.SecureArray`1.Best(Int32 size, SecureArrayCall secureArrayCall)
   at Isopoh.Cryptography.Argon2.Argon2.Hash(String password, String secret, Int32 timeCost, Int32 memoryCost, Int32 parallelism, Argon2Type type, Int32 hashLength, SecureArrayCall secureArrayCall)
   at Isopoh.Cryptography.Argon2.Argon2.Hash(String password, Int32 timeCost, Int32 memoryCost, Int32 parallelism, Argon2Type type, Int32 hashLength, SecureArrayCall secureArrayCall)

microsoft.net.native.compiler\2.2.9-rel-29512-01\tools\Microsoft.NetNative.targets(805,5): warning :
MCG : warning MCG0007: Unresolved P/Invoke method 'psapi.dll!GetProcessMemoryInfo' for method 'System.Boolean Isopoh.Cryptography.SecureArray.WindowsNative.UnsafeNativeMethods.GetProcessMemoryInfo(System.IntPtr, Isopoh.Cryptography.SecureArray.WindowsNative.UnsafeNativeMethods.ProcessMemoryCounters, System.UInt32)'. Calling this method would throw exception at runtime. Please make sure the P/Invoke either points to a Windows API allowed in UWP applications, or a native DLL that is part of the package. If for some reason your P/Invoke does not satisfy those requirements, please use [DllImport(ExactSpelling=true) to indicate that you understand the implications of using non-UWP APIs.
MCG : warning MCG0007: Unresolved P/Invoke method 'ntdll.dll!RtlZeroMemory' for method 'System.Void Isopoh.Cryptography.SecureArray.WindowsNative.UnsafeNativeMethods.RtlZeroMemory(System.IntPtr, System.UIntPtr)'. Calling this method would throw exception at runtime. Please make sure the P/Invoke either points to a Windows API allowed in UWP applications, or a native DLL that is part of the package. If for some reason your P/Invoke does not satisfy those requirements, please use [DllImport(ExactSpelling=true) to indicate that you understand the implications of using non-UWP APIs.
MCG : warning MCG0007: Unresolved P/Invoke method 'libSystem!mlock' for method 'System.Int32 Isopoh.Cryptography.SecureArray.OsxNative.UnsafeNativeMethods.OsxMlock(System.IntPtr, System.UIntPtr)'. Calling this method would throw exception at runtime. Please make sure the P/Invoke either points to a Windows API allowed in UWP applications, or a native DLL that is part of the package. If for some reason your P/Invoke does not satisfy those requirements, please use [DllImport(ExactSpelling=true) to indicate that you understand the implications of using non-UWP APIs.
MCG : warning MCG0007: Unresolved P/Invoke method 'libSystem!munlock' for method 'System.Int32 Isopoh.Cryptography.SecureArray.OsxNative.UnsafeNativeMethods.OsxMunlock(System.IntPtr, System.UIntPtr)'. Calling this method would throw exception at runtime. Please make sure the P/Invoke either points to a Windows API allowed in UWP applications, or a native DLL that is part of the package. If for some reason your P/Invoke does not satisfy those requirements, please use [DllImport(ExactSpelling=true) to indicate that you understand the implications of using non-UWP APIs.
MCG : warning MCG0007: Unresolved P/Invoke method 'libSystem!memset' for method 'System.IntPtr Isopoh.Cryptography.SecureArray.OsxNative.UnsafeNativeMethods.OsxMemset(System.IntPtr, System.Int32, System.UIntPtr)'. Calling this method would throw exception at runtime. Please make sure the P/Invoke either points to a Windows API allowed in UWP applications, or a native DLL that is part of the package. If for some reason your P/Invoke does not satisfy those requirements, please use [DllImport(ExactSpelling=true) to indicate that you understand the implications of using non-UWP APIs.
MCG : warning MCG0007: Unresolved P/Invoke method 'libc!mlock' for method 'System.Int32 Isopoh.Cryptography.SecureArray.LinuxNative.UnsafeNativeMethods.LinuxMlock(System.IntPtr, System.UIntPtr)'. Calling this method would throw exception at runtime. Please make sure the P/Invoke either points to a Windows API allowed in UWP applications, or a native DLL that is part of the package. If for some reason your P/Invoke does not satisfy those requirements, please use [DllImport(ExactSpelling=true) to indicate that you understand the implications of using non-UWP APIs.
MCG : warning MCG0007: Unresolved P/Invoke method 'libc!munlock' for method 'System.Int32 Isopoh.Cryptography.SecureArray.LinuxNative.UnsafeNativeMethods.LinuxMunlock(System.IntPtr, System.UIntPtr)'. Calling this method would throw exception at runtime. Please make sure the P/Invoke either points to a Windows API allowed in UWP applications, or a native DLL that is part of the package. If for some reason your P/Invoke does not satisfy those requirements, please use [DllImport(ExactSpelling=true) to indicate that you understand the implications of using non-UWP APIs.
MCG : warning MCG0007: Unresolved P/Invoke method 'libc!memset' for method 'System.IntPtr Isopoh.Cryptography.SecureArray.LinuxNative.UnsafeNativeMethods.LinuxMemset(System.IntPtr, System.Int32, System.UIntPtr)'. Calling this method would throw exception at runtime. Please make sure the P/Invoke either points to a Windows API allowed in UWP applications, or a native DLL that is part of the package. If for some reason your P/Invoke does not satisfy those requirements, please use [DllImport(ExactSpelling=true) to indicate that you understand the implications of using non-UWP APIs.
MCG : warning MCG0007: Unresolved P/Invoke method 'libc!getrlimit' for method 'System.Int32 Isopoh.Cryptography.SecureArray.LinuxNative.UnsafeNativeMethods.LinuxGetRLimit(System.Int32, Isopoh.Cryptography.SecureArray.LinuxNative.UnsafeNativeMethods.LinuxRlimit)'. Calling this method would throw exception at runtime. Please make sure the P/Invoke either points to a Windows API allowed in UWP applications, or a native DLL that is part of the package. If for some reason your P/Invoke does not satisfy those requirements, please use [DllImport(ExactSpelling=true) to indicate that you understand the implications of using non-UWP APIs.
MCG : warning MCG0007: Unresolved P/Invoke method 'libc!setrlimit' for method 'System.Int32 Isopoh.Cryptography.SecureArray.LinuxNative.UnsafeNativeMethods.LinuxSetRLimit(System.Int32, Isopoh.Cryptography.SecureArray.LinuxNative.UnsafeNativeMethods.LinuxRlimit)'. Calling this method would throw exception at runtime. Please make sure the P/Invoke either points to a Windows API allowed in UWP applications, or a native DLL that is part of the package. If for some reason your P/Invoke does not satisfy those requirements, please use [DllImport(ExactSpelling=true) to indicate that you understand the implications of using non-UWP APIs.
MCG : warning MCG0007: Unresolved P/Invoke method 'libc!strerror_r' for method 'System.IntPtr Isopoh.Cryptography.SecureArray.LinuxNative.UnsafeNativeMethods.LinuxSterrorR(System.Int32, System.IntPtr, System.UInt64)'. Calling this method would throw exception at runtime. Please make sure the P/Invoke either points to a Windows API allowed in UWP applications, or a native DLL that is part of the package. If for some reason your P/Invoke does not satisfy those requirements, please use [DllImport(ExactSpelling=true) to indicate that you understand the implications of using non-UWP APIs.
MCG : warning MCG0007: Unresolved P/Invoke method 'libc!sysctl' for method 'System.Int32 Microsoft.DotNet.PlatformAbstractions.Native.NativeMethods.Darwin.sysctl(System.Int32*, System.UInt32, System.Byte*, System.UInt32*, System.IntPtr, System.UInt32)'. Calling this method would throw exception at runtime. Please make sure the P/Invoke either points to a Windows API allowed in UWP applications, or a native DLL that is part of the package. If for some reason your P/Invoke does not satisfy those requirements, please use [DllImport(ExactSpelling=true) to indicate that you understand the implications of using non-UWP APIs.
MCG : warning MCG0007: Unresolved P/Invoke method 'ntdll!RtlGetVersion' for method 'System.Int32 Microsoft.DotNet.PlatformAbstractions.Native.NativeMethods.Windows.RtlGetVersion(Microsoft.DotNet.PlatformAbstractions.Native.NativeMethods.Windows.RTL_OSVERSIONINFOEX)'. Calling this method would throw exception at runtime. Please make sure the P/Invoke either points to a Windows API allowed in UWP applications, or a native DLL that is part of the package. If for some reason your P/Invoke does not satisfy those requirements, please use [DllImport(ExactSpelling=true) to indicate that you understand the implications of using non-UWP APIs.````

DllNotFoundException: Unable to load DLL 'kernel32.dll': The specified module or one of its dependencies could not be found.
(Exception from HRESULT: 0x8007007E)
Isopoh.Cryptography.SecureArray.SecureArray.GetModuleHandle(string moduleName)

TypeInitializationException: The type initializer for 'Isopoh.Cryptography.SecureArray.SecureArray' threw an exception.
Isopoh.Cryptography.Argon2.Argon2.Verify(string encoded, string password, SecureArrayCall secureArrayCall)

Small Object Heap: code that allocates a lot of memory in SOH
Allocated object type: UInt64[]
Allocated size: 2,693.9 MB

Argon2Config Argon2DefaultConfig = new Argon2Config
        {
            Type = Argon2Type.DataIndependentAddressing,
            Version = Argon2Version.Nineteen,
            TimeCost = 3,
            Lanes = 4,
            MemoryCost = 64 * 1024,
            Threads = 1,
            HashLength = 32,
        };

{Isopoh.Cryptography.Argon2.Argon2Config}
    AssociatedData: null
    ClearPassword: false
    ClearSecret: false
    HashLength: 32
    Lanes: 4
    MemoryCost: 131072
    Password: null
    Salt: null
    Secret: null
    SecureArrayCall: {Isopoh.Cryptography.SecureArray.DefaultWindowsSecureArrayCall}
    Threads: 4
    TimeCost: 3
    Type: HybridAddressing
    Version: Nineteen

Additional information: A call to PInvoke function 
'Isopoh.Cryptography.SecureArray!Isopoh.Cryptography.SecureArray.SecureArray::SetProcessWorkingSetSizeEx' has unbalanced the stack. This is likely because the managed PInvoke signature does not match the unmanaged target signature. Check that the calling convention and parameters of the PInvoke signature match the target unmanaged signature.

using System;
using Isopoh.Cryptography.Argon2;

namespace SnippetTester
{
    class Program
    {
        static void Main(string[] args)
        {
            for (int i = 0; i <= 1000000; i++)
            {
                Console.WriteLine("Argon2 (b,b) is: " + Argon2.Verify("$argon2i$v=19$m=65536,t=3,p=1$M2f6+jnVc4dyL3BfMQRzoA==$jO/fOrgqxX90XDVhiYZgIVJJcw0lzIXtRFRCEggXYV8=", "b"));
            }
        }
    }
}

string password = "password";
string hash = Argon2.Hash(password, hashLength: 16);
bool isPasswordValid = Argon2.Verify(hash, password);

string password = "password";
string hash = Argon2.Hash(password, hashLength: 16);

var config = new Argon2Config
{
    HashLength = 16,
    Password = Encoding.UTF8.GetBytes(password)
};
var isPasswordValid = Argon2.Verify(hash, config);`

// WORKS
var plaintextPassword = "MyPassword";
var hashedPassword= Argon2.Hash(plaintextPassword);
var check = Argon2.Verify(hashedPassword, plaintextPassword);
// check == True

// DOES NOT WORK
var plaintextPassword = "MyPassword";
var hashedPassword= Argon2.Hash(plaintextPassword, "mysecret");
var check = Argon2.Verify(hashedPassword, plaintextPassword);
// check == False