Merge branch '110-accountV2-support'

Author: gpailler

MegaApiClient.Tests/Context/AuthenticatedTestContext.cs

@@ -11,7 +11,8 @@ public class AuthenticatedLoginTestsCollection : ICollectionFixture<Authenticate
   public class AuthenticatedTestContext : TestContext, IDisposable
   {
     private const string MegaApiClientPasswordEnvironment = "MEGAAPICLIENT_PASSWORD";
-    internal const string Username = "[email protected]";
+    internal const string UsernameAccountV1 = "[email protected]";
+    internal const string UsernameAccountV2 = "[email protected]";
     internal static readonly string Password = Environment.GetEnvironmentVariable(MegaApiClientPasswordEnvironment);
 
     internal const string FileLink = "https://mega.nz/#!bkwkHC7D!AWJuto8_fhleAI2WG0RvACtKkL_s9tAtvBXXDUp2bQk";
@@ -91,7 +92,7 @@ public virtual void Dispose()
     protected override void ConnectClient(IMegaApiClient client)
     {
       Assert.False(string.IsNullOrEmpty(Password), $"Environment variable {MegaApiClientPasswordEnvironment} not set.");
-      client.Login(Username, Password);
+      client.Login(UsernameAccountV1, Password);
     }
 
     protected override IEnumerable<string> GetProtectedNodes()

MegaApiClient.Tests/Login.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
+using System.Linq;
 using CG.Web.MegaApiClient.Tests.Context;
 using Moq;
 using Newtonsoft.Json;
@@ -71,25 +72,38 @@ public void Login_InvalidCredentials_Throws(string email, string password, ApiRe
       Assert.Equal(expectedErrorCode, exception.ApiResultCode);
     }
 
-    [Theory, MemberData(nameof(Credentials))]
+    [Theory, MemberData(nameof(AllValidCredentials))]
     public void Login_ValidCredentials_Succeeds(string email, string password)
     {
       Assert.NotNull(this.context.Client.Login(email, password));
       Assert.True(this.context.Client.IsLoggedIn);
     }
 
-    public static IEnumerable<object[]> Credentials
+    public static IEnumerable<object[]> CredentialsV1
     {
       get
       {
-        Assert.NotEmpty(AuthenticatedTestContext.Username);
+        Assert.NotEmpty(AuthenticatedTestContext.UsernameAccountV1);
         Assert.NotEmpty(AuthenticatedTestContext.Password);
 
-        yield return new[] {AuthenticatedTestContext.Username, AuthenticatedTestContext.Password };
+        yield return new[] {AuthenticatedTestContext.UsernameAccountV1, AuthenticatedTestContext.Password };
       }
     }
 
-    [Theory, MemberData(nameof(Credentials))]
+    public static IEnumerable<object[]> CredentialsV2
+    {
+      get
+      {
+        Assert.NotEmpty(AuthenticatedTestContext.UsernameAccountV2);
+        Assert.NotEmpty(AuthenticatedTestContext.Password);
+
+        yield return new[] {AuthenticatedTestContext.UsernameAccountV2, AuthenticatedTestContext.Password };
+      }
+    }
+
+    public static IEnumerable<object[]> AllValidCredentials => CredentialsV1.Concat(CredentialsV2);
+
+    [Theory, MemberData(nameof(AllValidCredentials))]
     public void LoginTwice_ValidCredentials_Throws(string email, string password)
     {
       this.context.Client.Login(email, password);
@@ -114,7 +128,7 @@ public void LoginAnonymousTwice_Throws()
       Assert.Equal("Already logged in", exception.Message);
     }
 
-    [Theory, MemberData(nameof(Credentials))]
+    [Theory, MemberData(nameof(AllValidCredentials))]
     public void LogoutAfterLogin_Succeeds(string email, string password)
     {
       this.context.Client.Login(email, password);
@@ -124,7 +138,7 @@ public void LogoutAfterLogin_Succeeds(string email, string password)
       Assert.False(this.context.Client.IsLoggedIn);
     }
 
-    [Theory, MemberData(nameof(Credentials))]
+    [Theory, MemberData(nameof(AllValidCredentials))]
     public void LogoutTwiceAfterLogin_Throws(string email, string password)
     {
       this.context.Client.Login(email, password);
@@ -147,10 +161,10 @@ public void Login_NullAuthInfos_Throws()
       Assert.Throws<ArgumentNullException>("authInfos", () => this.context.Client.Login((MegaApiClient.AuthInfos)null));
     }
 
-    [Theory, MemberData(nameof(Credentials))]
+    [Theory, MemberData(nameof(AllValidCredentials))]
     public void Login_DeserializedAuthInfos_Succeeds(string email, string password)
     {
-      var authInfos = MegaApiClient.GenerateAuthInfos(email, password);
+      var authInfos = this.context.Client.GenerateAuthInfos(email, password);
       var serializedAuthInfos = JsonConvert.SerializeObject(authInfos, Formatting.None).Replace('\"', '\'');
       var deserializedAuthInfos = JsonConvert.DeserializeObject<MegaApiClient.AuthInfos>(serializedAuthInfos);
 
@@ -161,13 +175,13 @@ public void Login_DeserializedAuthInfos_Succeeds(string email, string password)
     [Theory, MemberData(nameof(InvalidCredentials))]
     public void GenerateAuthInfos_InvalidCredentials_Throws(string email, string password, string expectedMessage)
     {
-      Assert.Throws<ArgumentNullException>(expectedMessage, () => MegaApiClient.GenerateAuthInfos(email, password));
+      Assert.Throws<ArgumentNullException>(expectedMessage, () => this.context.Client.GenerateAuthInfos(email, password));
     }
 
     [Theory, InlineData("[email protected]", "password", "{'Email':'[email protected]','Hash':'ObELy57HULI','PasswordAesKey':'ZAM5cl5uvROiXwBSEp98sQ=='}")]
     public void GenerateAuthInfos_ValidCredentials_Succeeds(string email, string password, string expectedResult)
     {
-      var authInfos = MegaApiClient.GenerateAuthInfos(email, password);
+      var authInfos = this.context.Client.GenerateAuthInfos(email, password);
       var result = JsonConvert.SerializeObject(authInfos, Formatting.None).Replace('\"', '\'');
 
       Assert.Equal(expectedResult, result);
@@ -212,8 +226,8 @@ public static IEnumerable<object[]> MethodsWithMandatoryLogin()
       yield return new object[] { (Action<IMegaApiClient>)(x => x.GetAccountInformation()) };
     }
 
-    [Theory, MemberData(nameof(Credentials))]
-    public void GetAccountInformation_AuthenticatedUser_Succeeds(string email, string password)
+    [Theory, MemberData(nameof(CredentialsV1))]
+    public void GetAccountInformation_AuthenticatedUserV1_Succeeds(string email, string password)
     {
       this.context.Client.Login(email, password);
 
@@ -228,6 +242,18 @@ public void GetAccountInformation_AuthenticatedUser_Succeeds(string email, strin
       Assert.Equal(1046530 + AuthenticatedTestContext.FileSize + AuthenticatedTestContext.SubFolderFileSize, accountInformation.UsedQuota); // 1046530 is from incoming shares
     }
 
+    [Theory, MemberData(nameof(CredentialsV2))]
+    public void GetAccountInformation_AuthenticatedUserV2_Succeeds(string email, string password)
+    {
+      this.context.Client.Login(email, password);
+
+      IAccountInformation accountInformation = this.context.Client.GetAccountInformation();
+
+      Assert.NotNull(accountInformation);
+      Assert.Equal(53687091200, accountInformation.TotalQuota);
+      Assert.Equal(0, accountInformation.UsedQuota);
+    }
+
     [Fact]
     public void GetAccountInformation_AnonymousUser_Succeeds()
     {

MegaApiClient.Tests/MegaApiClientAsyncWrapper.cs

@@ -144,6 +144,11 @@ public INode Rename(INode node, string newName)
       return this.UnwrapException(() => this.client.RenameAsync(node, newName).Result);
     }
 
+    public MegaApiClient.AuthInfos GenerateAuthInfos(string email, string password)
+    {
+      return this.UnwrapException(() => this.client.GenerateAuthInfosAsync(email, password).Result);
+    }
+
     public Task<MegaApiClient.LogonSessionToken> LoginAsync(string email, string password)
     {
       return this.client.LoginAsync(email, password);
@@ -254,6 +259,11 @@ public Task<IEnumerable<INode>> GetNodesFromLinkAsync(Uri uri)
       return this.client.GetNodesFromLinkAsync(uri);
     }
 
+    public Task<MegaApiClient.AuthInfos> GenerateAuthInfosAsync(string email, string password)
+    {
+      return this.client.GenerateAuthInfosAsync(email, password);
+    }
+
     private T UnwrapException<T>(Func<T> action)
     {
       try

MegaApiClient/Cryptography/PBKDF2.cs

@@ -0,0 +1,186 @@
+//Copyright (c) 2012 Josip Medved <[email protected]>
+// From https://www.medo64.com/2012/04/pbkdf2-with-sha-256-and-others/
+//2012-04-12: Initial version.
+namespace Medo.Security.Cryptography
+{
+  using System;
+  using System.Security.Cryptography;
+  using System.Text;
+
+  /// <summary>
+  /// Generic PBKDF2 implementation.
+  /// </summary>
+  /// <example>This sample shows how to initialize class with SHA-256 HMAC.
+  /// <code>
+  /// using (var hmac = new HMACSHA256()) {
+  ///     var df = new Pbkdf2(hmac, "password", "salt");
+  ///     var bytes = df.GetBytes();
+  /// }
+  /// </code>
+  /// </example>
+  [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "Pbkdf", Justification = "Spelling is correct.")]
+  public class Pbkdf2
+  {
+
+    /// <summary>
+    /// Creates new instance.
+    /// </summary>
+    /// <param name="algorithm">HMAC algorithm to use.</param>
+    /// <param name="password">The password used to derive the key.</param>
+    /// <param name="salt">The key salt used to derive the key.</param>
+    /// <param name="iterations">The number of iterations for the operation.</param>
+    /// <exception cref="System.ArgumentNullException">Algorithm cannot be null - Password cannot be null. -or- Salt cannot be null.</exception>
+    public Pbkdf2(HMAC algorithm, Byte[] password, Byte[] salt, Int32 iterations)
+    {
+      if (algorithm == null) { throw new ArgumentNullException("algorithm", "Algorithm cannot be null."); }
+      if (salt == null) { throw new ArgumentNullException("salt", "Salt cannot be null."); }
+      if (password == null) { throw new ArgumentNullException("password", "Password cannot be null."); }
+      this.Algorithm = algorithm;
+      this.Algorithm.Key = password;
+      this.Salt = salt;
+      this.IterationCount = iterations;
+      this.BlockSize = this.Algorithm.HashSize / 8;
+      this.BufferBytes = new byte[this.BlockSize];
+    }
+
+    /// <summary>
+    /// Creates new instance.
+    /// </summary>
+    /// <param name="algorithm">HMAC algorithm to use.</param>
+    /// <param name="password">The password used to derive the key.</param>
+    /// <param name="salt">The key salt used to derive the key.</param>
+    /// <exception cref="System.ArgumentNullException">Algorithm cannot be null - Password cannot be null. -or- Salt cannot be null.</exception>
+    public Pbkdf2(HMAC algorithm, Byte[] password, Byte[] salt)
+        : this(algorithm, password, salt, 1000)
+    {
+    }
+
+    /// <summary>
+    /// Creates new instance.
+    /// </summary>
+    /// <param name="algorithm">HMAC algorithm to use.</param>
+    /// <param name="password">The password used to derive the key.</param>
+    /// <param name="salt">The key salt used to derive the key.</param>
+    /// <param name="iterations">The number of iterations for the operation.</param>
+    /// <exception cref="System.ArgumentNullException">Algorithm cannot be null - Password cannot be null. -or- Salt cannot be null.</exception>
+    public Pbkdf2(HMAC algorithm, String password, String salt, Int32 iterations) :
+        this(algorithm, UTF8Encoding.UTF8.GetBytes(password), UTF8Encoding.UTF8.GetBytes(salt), iterations)
+    {
+    }
+
+    /// <summary>
+    /// Creates new instance.
+    /// </summary>
+    /// <param name="algorithm">HMAC algorithm to use.</param>
+    /// <param name="password">The password used to derive the key.</param>
+    /// <param name="salt">The key salt used to derive the key.</param>
+    /// <exception cref="System.ArgumentNullException">Algorithm cannot be null - Password cannot be null. -or- Salt cannot be null.</exception>
+    public Pbkdf2(HMAC algorithm, String password, String salt) :
+        this(algorithm, password, salt, 1000)
+    {
+    }
+    
+    private readonly int BlockSize;
+    private uint BlockIndex = 1;
+
+    private byte[] BufferBytes;
+    private int BufferStartIndex = 0;
+    private int BufferEndIndex = 0;
+
+    /// <summary>
+    /// Gets algorithm used for generating key.
+    /// </summary>
+    public HMAC Algorithm { get; private set; }
+
+    /// <summary>
+    /// Gets salt bytes.
+    /// </summary>
+    [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1819:PropertiesShouldNotReturnArrays", Justification = "Byte array is proper return value in this case.")]
+    public Byte[] Salt { get; private set; }
+
+    /// <summary>
+    /// Gets iteration count.
+    /// </summary>
+    public Int32 IterationCount { get; private set; }
+
+    /// <summary>
+    /// Returns a pseudo-random key from a password, salt and iteration count.
+    /// </summary>
+    /// <param name="count">Number of bytes to return.</param>
+    /// <returns>Byte array.</returns>
+    public Byte[] GetBytes(int count)
+    {
+      byte[] result = new byte[count];
+      int resultOffset = 0;
+      int bufferCount = this.BufferEndIndex - this.BufferStartIndex;
+
+      if (bufferCount > 0)
+      { //if there is some data in buffer
+        if (count < bufferCount)
+        { //if there is enough data in buffer
+          Buffer.BlockCopy(this.BufferBytes, this.BufferStartIndex, result, 0, count);
+          this.BufferStartIndex += count;
+          return result;
+        }
+        Buffer.BlockCopy(this.BufferBytes, this.BufferStartIndex, result, 0, bufferCount);
+        this.BufferStartIndex = this.BufferEndIndex = 0;
+        resultOffset += bufferCount;
+      }
+
+      while (resultOffset < count)
+      {
+        int needCount = count - resultOffset;
+        this.BufferBytes = this.Func();
+        if (needCount > this.BlockSize)
+        { //we one (or more) additional passes
+          Buffer.BlockCopy(this.BufferBytes, 0, result, resultOffset, this.BlockSize);
+          resultOffset += this.BlockSize;
+        }
+        else
+        {
+          Buffer.BlockCopy(this.BufferBytes, 0, result, resultOffset, needCount);
+          this.BufferStartIndex = needCount;
+          this.BufferEndIndex = this.BlockSize;
+          return result;
+        }
+      }
+      return result;
+    }
+
+    private byte[] Func()
+    {
+      var hash1Input = new byte[this.Salt.Length + 4];
+      Buffer.BlockCopy(this.Salt, 0, hash1Input, 0, this.Salt.Length);
+      Buffer.BlockCopy(GetBytesFromInt(this.BlockIndex), 0, hash1Input, this.Salt.Length, 4);
+      var hash1 = this.Algorithm.ComputeHash(hash1Input);
+
+      byte[] finalHash = hash1;
+      for (int i = 2; i <= this.IterationCount; i++)
+      {
+        hash1 = this.Algorithm.ComputeHash(hash1, 0, hash1.Length);
+        for (int j = 0; j < this.BlockSize; j++)
+        {
+          finalHash[j] = (byte)(finalHash[j] ^ hash1[j]);
+        }
+      }
+      if (this.BlockIndex == uint.MaxValue) { throw new InvalidOperationException("Derived key too long."); }
+      this.BlockIndex += 1;
+
+      return finalHash;
+    }
+
+    private static byte[] GetBytesFromInt(uint i)
+    {
+      var bytes = BitConverter.GetBytes(i);
+      if (BitConverter.IsLittleEndian)
+      {
+        return new byte[] { bytes[3], bytes[2], bytes[1], bytes[0] };
+      }
+      else
+      {
+        return bytes;
+      }
+    }
+
+  }
+}

MegaApiClient/Interface/IMegaApiClient.cs

@@ -80,5 +80,7 @@ public partial interface IMegaApiClient
     INode Move(INode node, INode destinationParentNode);
 
     INode Rename(INode node, string newName);
+
+    MegaApiClient.AuthInfos GenerateAuthInfos(string email, string password);
   }
 }

MegaApiClient/Interface/IMegaApiClientAsync.cs

@@ -52,6 +52,8 @@ public partial interface IMegaApiClient
     Task<INodeInfo> GetNodeFromLinkAsync(Uri uri);
 
     Task<IEnumerable<INode>> GetNodesFromLinkAsync(Uri uri);
+
+    Task<MegaApiClient.AuthInfos> GenerateAuthInfosAsync(string email, string password);
   }
 }
 #endif