Ejemplo n.º 1
0
        // Token: 0x06000947 RID: 2375 RVA: 0x0004BB88 File Offset: 0x00049D88
        public Stream Download(INode node, CancellationToken?cancellationToken = null)
        {
            if (node == null)
            {
                throw new ArgumentNullException("node");
            }
            if (node.Type != NodeType.File)
            {
                throw new ArgumentException("Invalid node");
            }
            INodeCrypto nodeCrypto = node as INodeCrypto;

            if (nodeCrypto == null)
            {
                throw new ArgumentException("node must implement INodeCrypto");
            }
            this.EnsureLoggedIn();
            DownloadUrlRequest  request             = new DownloadUrlRequest(node);
            DownloadUrlResponse downloadUrlResponse = this.Request <DownloadUrlResponse>(request, null);
            Stream stream = new MegaAesCtrStreamDecrypter(new BufferedStream(this.webClient.GetRequestRaw(new Uri(downloadUrlResponse.Url))), downloadUrlResponse.Size, nodeCrypto.Key, nodeCrypto.Iv, nodeCrypto.MetaMac);

            if (cancellationToken != null)
            {
                stream = new CancellableStream(stream, cancellationToken.Value);
            }
            return(stream);
        }
Ejemplo n.º 2
0
        // Token: 0x0600094E RID: 2382 RVA: 0x0004C218 File Offset: 0x0004A418
        public INode Rename(INode node, string newName)
        {
            if (node == null)
            {
                throw new ArgumentNullException("node");
            }
            if (node.Type != NodeType.Directory && node.Type != NodeType.File)
            {
                throw new ArgumentException("Invalid node type");
            }
            if (string.IsNullOrEmpty(newName))
            {
                throw new ArgumentNullException("newName");
            }
            INodeCrypto nodeCrypto = node as INodeCrypto;

            if (nodeCrypto == null)
            {
                throw new ArgumentException("node must implement INodeCrypto");
            }
            this.EnsureLoggedIn();
            byte[] data = Crypto.EncryptAttributes(new Attributes(newName, ((Node)node).Attributes), nodeCrypto.Key);
            this.Request(new RenameRequest(node, data.ToBase64()));
            return(this.GetNodes().First((INode n) => n.Equals(node)));
        }
Ejemplo n.º 3
0
        // Token: 0x0600098C RID: 2444 RVA: 0x0003D668 File Offset: 0x0003B868
        public ShareNodeRequest(INode node, byte[] masterKey, IEnumerable <INode> nodes) : base("s2")
        {
            this.Id      = node.Id;
            this.Options = new object[]
            {
                new
                {
                    r = 0,
                    u = "EXP"
                }
            };
            INodeCrypto nodeCrypto = (INodeCrypto)node;

            byte[] array = nodeCrypto.SharedKey;
            if (array == null)
            {
                array = Crypto.CreateAesKey();
            }
            this.SharedKey = Crypto.EncryptKey(array, masterKey).ToBase64();
            if (nodeCrypto.SharedKey == null)
            {
                this.Share = new ShareData(node.Id);
                this.Share.AddItem(node.Id, nodeCrypto.FullKey, array);
                foreach (INode node2 in this.GetRecursiveChildren(nodes.ToArray <INode>(), node))
                {
                    this.Share.AddItem(node2.Id, ((INodeCrypto)node2).FullKey, array);
                }
            }
            byte[] data = (node.Id + node.Id).ToBytes();
            this.HandleAuth = Crypto.EncryptKey(data, masterKey).ToBase64();
        }
Ejemplo n.º 4
0
        // Token: 0x06000944 RID: 2372 RVA: 0x0004B9A0 File Offset: 0x00049BA0
        public Uri GetDownloadLink(INode node)
        {
            if (node == null)
            {
                throw new ArgumentNullException("node");
            }
            if (node.Type != NodeType.File && node.Type != NodeType.Directory)
            {
                throw new ArgumentException("Invalid node");
            }
            this.EnsureLoggedIn();
            if (node.Type == NodeType.Directory)
            {
                this.Request(new ShareNodeRequest(node, this.masterKey, this.GetNodes()));
                node = this.GetNodes().First((INode x) => x.Equals(node));
            }
            INodeCrypto nodeCrypto = node as INodeCrypto;

            if (nodeCrypto == null)
            {
                throw new ArgumentException("node must implement INodeCrypto");
            }
            GetDownloadLinkRequest request = new GetDownloadLinkRequest(node);
            string arg = this.Request <string>(request, null);

            return(new Uri(MegaApiClient.BaseUri, string.Format("/{0}/{1}#{2}", (node.Type == NodeType.Directory) ? "folder" : "file", arg, (node.Type == NodeType.Directory) ? nodeCrypto.SharedKey.ToBase64() : nodeCrypto.FullKey.ToBase64())));
        }
Ejemplo n.º 5
0
        /// <summary>
        /// Retrieve a Stream to download and decrypt the specified node
        /// </summary>
        /// <param name="node">Node to download (only <see cref="NodeType.File" /> can be downloaded)</param>
        /// <exception cref="NotSupportedException">Not logged in</exception>
        /// <exception cref="ApiException">Mega.co.nz service reports an error</exception>
        /// <exception cref="ArgumentNullException">node or outputFile is null</exception>
        /// <exception cref="ArgumentException">node is not valid (only <see cref="NodeType.File" /> can be downloaded)</exception>
        /// <exception cref="DownloadException">Checksum is invalid. Downloaded data are corrupted</exception>
        public Stream Download(INode node)
        {
            if (node == null)
            {
                throw new ArgumentNullException("node");
            }

            if (node.Type != NodeType.File)
            {
                throw new ArgumentException("Invalid node");
            }

            INodeCrypto nodeCrypto = node as INodeCrypto;

            if (nodeCrypto == null)
            {
                throw new ArgumentException("node must implement INodeCrypto");
            }

            this.EnsureLoggedIn();

            // Retrieve download URL
            DownloadUrlRequest  downloadRequest  = new DownloadUrlRequest(node);
            DownloadUrlResponse downloadResponse = this.Request <DownloadUrlResponse>(downloadRequest);

            Stream dataStream = this.webClient.GetRequestRaw(new Uri(downloadResponse.Url));

            return(new MegaAesCtrStreamDecrypter(dataStream, downloadResponse.Size, nodeCrypto.Key, nodeCrypto.Iv, nodeCrypto.MetaMac));
        }
Ejemplo n.º 6
0
        // Token: 0x06000A44 RID: 2628 RVA: 0x0004D9E8 File Offset: 0x0004BBE8
        private CreateNodeRequest(INode parentNode, NodeType type, string attributes, string encryptedKey, byte[] key, string completionHandle) : base("p")
        {
            this.ParentId = parentNode.Id;
            this.Nodes    = new CreateNodeRequest.CreateNodeRequestData[]
            {
                new CreateNodeRequest.CreateNodeRequestData
                {
                    Attributes       = attributes,
                    Key              = encryptedKey,
                    Type             = type,
                    CompletionHandle = completionHandle
                }
            };
            INodeCrypto nodeCrypto = parentNode as INodeCrypto;

            if (nodeCrypto == null)
            {
                throw new ArgumentException("parentNode node must implement INodeCrypto");
            }
            if (nodeCrypto.SharedKey != null)
            {
                this.Share = new ShareData(parentNode.Id);
                this.Share.AddItem(completionHandle, key, nodeCrypto.SharedKey);
            }
        }
Ejemplo n.º 7
0
        public ShareNodeRequest(INode node, byte[] masterKey, IEnumerable <INode> nodes)
            : base("s2")
        {
            Id      = node.Id;
            Options = new object[] { new { r = 0, u = "EXP" } };

            INodeCrypto nodeCrypto = (INodeCrypto)node;

            byte[] uncryptedSharedKey = nodeCrypto.SharedKey;
            if (uncryptedSharedKey == null)
            {
                uncryptedSharedKey = Crypto.CreateAesKey();
            }

            SharedKey = Crypto.EncryptKey(uncryptedSharedKey, masterKey).ToBase64();

            if (nodeCrypto.SharedKey == null)
            {
                Share = new ShareData(node.Id);

                Share.AddItem(node.Id, nodeCrypto.FullKey, uncryptedSharedKey);

                // Add all children
                IEnumerable <INode> allChildren = GetRecursiveChildren(nodes.ToArray(), node);
                foreach (var child in allChildren)
                {
                    Share.AddItem(child.Id, ((INodeCrypto)child).FullKey, uncryptedSharedKey);
                }
            }

            byte[] handle = (node.Id + node.Id).ToBytes();
            HandleAuth = Crypto.EncryptKey(handle, masterKey).ToBase64();
        }
Ejemplo n.º 8
0
        /// <summary>
        /// Retrieve an url to download specified node
        /// </summary>
        /// <param name="node">Node to retrieve the download link (only <see cref="NodeType.File" /> or <see cref="NodeType.Directory" /> can be downloaded)</param>
        /// <returns>Download link to retrieve the node with associated key</returns>
        /// <exception cref="NotSupportedException">Not logged in</exception>
        /// <exception cref="ApiException">Mega.co.nz service reports an error</exception>
        /// <exception cref="ArgumentNullException">node is null</exception>
        /// <exception cref="ArgumentException">node is not valid (only <see cref="NodeType.File" /> or <see cref="NodeType.Directory" /> can be downloaded)</exception>
        public Uri GetDownloadLink(INode node)
        {
            if (node == null)
            {
                throw new ArgumentNullException("node");
            }

            if (node.Type != NodeType.File && node.Type != NodeType.Directory)
            {
                throw new ArgumentException("Invalid node");
            }

            INodeCrypto nodeCrypto = node as INodeCrypto;

            if (nodeCrypto == null)
            {
                throw new ArgumentException("node must implement INodeCrypto");
            }

            this.EnsureLoggedIn();

            GetDownloadLinkRequest request = new GetDownloadLinkRequest(node);
            string response = this.Request <string>(request);

            return(new Uri(BaseUri, string.Format(
                               "/#{0}!{1}!{2}",
                               node.Type == NodeType.Directory ? "F" : string.Empty,
                               response,
                               nodeCrypto.FullKey.ToBase64())));
        }
Ejemplo n.º 9
0
 public MegaKeyCrypto(INodeCrypto CryptoKey)
 {
     if (CryptoKey == null)
     {
         return;
     }
     this.key       = CryptoKey.Key;
     this.sharedkey = CryptoKey.SharedKey;
     this.iv        = CryptoKey.Iv;
     this.metamac   = CryptoKey.MetaMac;
     this.fullkey   = CryptoKey.FullKey;
 }
Ejemplo n.º 10
0
        /// <summary>
        /// Retrieve a Stream to download and decrypt the specified node
        /// </summary>
        /// <param name="node">Node to download (only <see cref="NodeType.File" /> can be downloaded)</param>
        /// <exception cref="NotSupportedException">Not logged in</exception>
        /// <exception cref="ApiException">Mega.co.nz service reports an error</exception>
        /// <exception cref="ArgumentNullException">node or outputFile is null</exception>
        /// <exception cref="ArgumentException">node is not valid (only <see cref="NodeType.File" /> can be downloaded)</exception>
        /// <exception cref="DownloadException">Checksum is invalid. Downloaded data are corrupted</exception>
        public Stream Download(INode node, CancellationToken?cancellationToken = null)
        {
            if (node == null)
            {
                throw new ArgumentNullException("node");
            }

            if (node.Type != NodeType.File)
            {
                throw new ArgumentException("Invalid node");
            }

            INodeCrypto nodeCrypto = node as INodeCrypto;

            if (nodeCrypto == null)
            {
                throw new ArgumentException("node must implement INodeCrypto");
            }

            this.EnsureLoggedIn();

            // Retrieve download URL
            DownloadUrlRequest  downloadRequest  = new DownloadUrlRequest(node);
            DownloadUrlResponse downloadResponse = this.Request <DownloadUrlResponse>(downloadRequest);

            Uri    downloadUrl = new Uri(downloadResponse.Url);
            Stream dataStream  = new SeekableReadStream(this.webClient.GetLength(downloadUrl), (buffer, bufferOffset, offset, count)
                                                        => this.webClient.GetRequestRawWithRange(
                                                            downloadUrl, offset, offset + count).Read(buffer, bufferOffset, count));

            Stream resultStream = new MegaAesCtrStreamDecrypter(dataStream, downloadResponse.Size, nodeCrypto.Key, nodeCrypto.Iv, nodeCrypto.MetaMac);

            if (cancellationToken.HasValue)
            {
                resultStream = new CancellableStream(resultStream, cancellationToken.Value);
            }

            return(resultStream);
        }
Ejemplo n.º 11
0
        public Stream Download(INode node, CancellationToken?cancellationToken = null)
#endif
        {
            if (node == null)
            {
                throw new ArgumentNullException("node");
            }

            if (node.Type != NodeType.File)
            {
                throw new ArgumentException("Invalid node");
            }

            INodeCrypto nodeCrypto = node as INodeCrypto;

            if (nodeCrypto == null)
            {
                throw new ArgumentException("node must implement INodeCrypto");
            }

            this.EnsureLoggedIn();

            // Retrieve download URL
            DownloadUrlRequest  downloadRequest  = new DownloadUrlRequest(node);
            DownloadUrlResponse downloadResponse = this.Request <DownloadUrlResponse>(downloadRequest);

            Stream dataStream = this.webClient.GetRequestRaw(new Uri(downloadResponse.Url));

            Stream resultStream = new MegaAesCtrStreamDecrypter(dataStream, downloadResponse.Size, nodeCrypto.Key, nodeCrypto.Iv, nodeCrypto.MetaMac);

#if !NET35
            if (cancellationToken.HasValue)
            {
                resultStream = new CancellableStream(resultStream, cancellationToken.Value);
            }
#endif
            return(resultStream);
        }
Ejemplo n.º 12
0
        /// <summary>
        /// Retrieve an url to download specified node
        /// </summary>
        /// <param name="node">Node to retrieve the download link (only <see cref="NodeType.File" /> or <see cref="NodeType.Directory" /> can be downloaded)</param>
        /// <returns>Download link to retrieve the node with associated key</returns>
        /// <exception cref="NotSupportedException">Not logged in</exception>
        /// <exception cref="ApiException">Mega.co.nz service reports an error</exception>
        /// <exception cref="ArgumentNullException">node is null</exception>
        /// <exception cref="ArgumentException">node is not valid (only <see cref="NodeType.File" /> or <see cref="NodeType.Directory" /> can be downloaded)</exception>
        public Uri GetDownloadLink(INode node)
        {
            if (node == null)
            {
                throw new ArgumentNullException("node");
            }

            if (node.Type != NodeType.File && node.Type != NodeType.Directory)
            {
                throw new ArgumentException("Invalid node");
            }

            this.EnsureLoggedIn();

            if (node.Type == NodeType.Directory)
            {
                // Request an export share on the node or we will receive an AccessDenied
                this.Request(new ShareNodeRequest(node, this.masterKey, this.GetNodes()));

                node = this.GetNodes().First(x => x.Equals(node));
            }

            INodeCrypto nodeCrypto = node as INodeCrypto;

            if (nodeCrypto == null)
            {
                throw new ArgumentException("node must implement INodeCrypto");
            }

            GetDownloadLinkRequest request = new GetDownloadLinkRequest(node);
            string response = this.Request <string>(request);

            return(new Uri(BaseUri, string.Format(
                               "/#{0}!{1}!{2}",
                               node.Type == NodeType.Directory ? "F" : string.Empty,
                               response,
                               node.Type == NodeType.Directory ? nodeCrypto.SharedKey.ToBase64() : nodeCrypto.FullKey.ToBase64())));
        }
Ejemplo n.º 13
0
            public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
            {
                ShareData data = value as ShareData;

                if (data == null)
                {
                    throw new ArgumentException("invalid data to serialize");
                }

                INodeCrypto parent = data.Parent as INodeCrypto;

                if (parent == null)
                {
                    throw new ArgumentException("parent node must implement INodeCrypto");
                }

                writer.WriteStartArray();

                if (parent.SharedKey != null)
                {
                    writer.WriteStartArray();
                    writer.WriteValue(data.Parent.Id);
                    writer.WriteEndArray();

                    writer.WriteStartArray();
                    writer.WriteValue(data.CompletionHandle);
                    writer.WriteEndArray();

                    writer.WriteStartArray();
                    writer.WriteValue(0);
                    writer.WriteValue(0);
                    writer.WriteValue(Crypto.EncryptAesEcb(data.Key, parent.SharedKey).ToBase64());
                    writer.WriteEndArray();
                }

                writer.WriteEndArray();
            }
Ejemplo n.º 14
0
 public MegaNzNode(string Name, string ID, string parentid, long Size, NodeType type, DateTime mod_d, INodeCrypto keyDeCrypt) : base(keyDeCrypt)
 {
     this.name     = Name;
     this.id       = ID;
     this.parentid = parentid;
     this.size     = Size;
     this.type     = type;
     this.mod_d    = mod_d;
 }
Ejemplo n.º 15
0
 public MegaNzNode(string ID, INodeCrypto keyDeCrypt) : this(null, ID, null, -1, NodeType.File, new DateTime(), keyDeCrypt)
 {
 }