Ejemplo n.º 1
0
        internal string SignSGAMessageWithCode(int[] SecretSalt, int[] SecretPW, string sgaMessage, string DisplayCode)
        {
            try
            {
                ExtKey masterKey = GetExtKey(SecretSalt, SecretPW);

                ExtKey masterKeyD = masterKey.Derive(GetCurrencyIndex("btc"), hardened: true);
                ExtKey key = masterKeyD.Derive((uint)0);
                byte[] keybytes = key.PrivateKey.ToBytes();
                Key pkey = new Key(keybytes, -1, false);
                BitcoinSecret bitcoinSecret = new BitcoinSecret(pkey, Network.Main);
                var address = bitcoinSecret.PubKey.GetAddress(GetBLKNetworkAlt("btc")).ToString();
                var signature = bitcoinSecret.PrivateKey.SignMessage(sgaMessage);
                Sclear.EraseBytes(keybytes);

                masterKeyD = null;
                key = null;
                pkey = null;
                NWS WS = new NWS();
                return WS.GetSGATokenForSignin(address, signature, DisplayCode);
            }
            catch
            {

                return "4";
            }
        }
Ejemplo n.º 2
0
 internal ApolloTaskTransferResponse APL_Sign(int[] SecretSalt, int[] SecretPW, BitfiWallet.NOXWS.NoxTxnProcess tproc)
 {
     ApolloTaskTransferResponse taskTransferResponse = new ApolloTaskTransferResponse();
     byte[] keybytes = HDDerriveKey(SecretSalt, SecretPW, tproc.NoxAddress.HDIndex, "apl");
     APLGen aPL = new APLGen();
     string fromadr = aPL.GetPublicKey(keybytes);
     if (fromadr != tproc.NoxAddress.BTCAddress)
     {
         Sclear.EraseBytes(keybytes);
         taskTransferResponse.Error = "Invalid information.";
         return taskTransferResponse;
     }
     try
     {
         string check = aPL.CheckTransactionError(tproc.MXTxn, tproc.ToAddress, tproc.Amount, tproc.FeeValue);
         if (!string.IsNullOrEmpty(check))
         {
             Sclear.EraseBytes(keybytes);
             taskTransferResponse.Error = check;
             return taskTransferResponse;
         }
         var signedtxn = aPL.SignTransaction(keybytes, tproc.MXTxn);
         Sclear.EraseBytes(keybytes);
         taskTransferResponse.TxnHex = signedtxn;
         return taskTransferResponse;
     }
     catch (Exception ex)
     {
         Sclear.EraseBytes(keybytes);
         taskTransferResponse.Error = ex.Message;
         return taskTransferResponse;
     }
 }
        //OTHER
        internal XMRTaskImageResponse XMR_GetImages(int[] SecretSalt, int[] SecretPW, BitfiWallet.NOXWS.ImageRequestTable[] requestTable)
        {
            XMRTaskImageResponse taskTransferResponse = new XMRTaskImageResponse();

            try
            {
                byte[]             keybytes = HDDerriveKey(SecretSalt, SecretPW, 0, "xmr");
                var                wlt      = MoneroWallet.Wallet.OpenWallet(keybytes);
                BitfiWallet.XMRGen xMRGen   = new BitfiWallet.XMRGen(wlt);
                var                resp     = xMRGen.XMR_GetImages(requestTable);

                taskTransferResponse.Error          = resp.Error;
                taskTransferResponse.SpendKeyImages = resp.SpendKeyImages;
                taskTransferResponse.WalletAddress  = resp.WalletAddress;

                Sclear.EraseBytes(keybytes);
                wlt.Dispose();
                return(taskTransferResponse);
            }
            catch
            {
                taskTransferResponse.Error = "1";
                return(taskTransferResponse);
            }
        }
Ejemplo n.º 4
0
        internal string GetTestHash(int[] SecretSalt, int[] SecretPW)
        {
            byte[] ssalt = new byte[SecretSalt.Length];
            for (int i = 0; i \            {
                ssalt[i] = Sclear.SCharImage(SecretSalt[i]).SBYTE;
            }
            byte[] spw = new byte[SecretPW.Length];
            for (int i = 0; i \            {

                spw[i] = Sclear.SCharImage(SecretPW[i]).SBYTE;
            }
            byte[] der = NBitcoin.Crypto.SCrypt.ComputeDerivedKey(spw, ssalt, 32768, 8, 4, 4, 64);
            if (der == null)
            {
                throw new Exception("Error, invalid info.");
            }
            using (var shacrypt = new System.Security.Cryptography.SHA256Managed())
            {
                byte[] hash = shacrypt.ComputeHash(der);
                string tval = Convert.ToBase64String(hash);
                Sclear.EraseBytes(ssalt);
                Sclear.EraseBytes(spw);
                Sclear.EraseBytes(der);
                Sclear.EraseBytes(hash);
                return tval;
            }
        }
        internal RipTaskTransferResponse Rip_Sign(int[] SecretSalt, int[] SecretPW, BitfiWallet.NOXWS.NoxTxnProcess tproc)
        {
            RipTaskTransferResponse taskTransferResponse = new RipTaskTransferResponse();

            byte[] keybytes = HDDerriveKey(SecretSalt, SecretPW, 0, "xrp");

            byte[] bts   = Convert.FromBase64String(tproc.MXTxn);
            string MXTxn = System.Text.Encoding.UTF8.GetString(bts);

            RipGen ripGen = new RipGen();

            string fromadr = ripGen.GetAddress(keybytes);

            if (fromadr != tproc.NoxAddress.BTCAddress)
            {
                Sclear.EraseBytes(keybytes);
                taskTransferResponse.Error = "Invalid information.";
                return(taskTransferResponse);
            }

            JsonSerializerSettings ser = new JsonSerializerSettings();

            ser.MissingMemberHandling  = MissingMemberHandling.Ignore;
            ser.NullValueHandling      = NullValueHandling.Ignore;
            ser.ObjectCreationHandling = ObjectCreationHandling.Auto;
            ser.TypeNameHandling       = TypeNameHandling.All;
            var data = JsonConvert.DeserializeObject <RipTxnModel>(MXTxn, ser);


            var chamount = Convert.ToDecimal(data.Amount) * 0.000001M;

            if (chamount > Convert.ToDecimal(tproc.Amount))
            {
                Sclear.EraseBytes(keybytes);
                taskTransferResponse.Error = "Error parsing amount.";
                return(taskTransferResponse);
            }
            if (data.Destination.ToUpper() != tproc.ToAddress.ToUpper())
            {
                Sclear.EraseBytes(keybytes);
                taskTransferResponse.Error = "Error parsing destination.";
                return(taskTransferResponse);
            }

            try
            {
                string txn = ripGen.CreateTxn(keybytes, MXTxn);

                Sclear.EraseBytes(keybytes);
                taskTransferResponse.TxnHex = txn;
                return(taskTransferResponse);
            }
            catch (Exception ex)
            {
                Sclear.EraseBytes(keybytes);
                taskTransferResponse.Error = ex.Message;
                return(taskTransferResponse);
            }
        }
        internal string GetNewAddress(int[] SecretSalt, int[] SecretPW, int hdIndex, string currencySymbol, string firstaddress, bool DoSegwit)
        {
            try
            {
                ExtKey masterKey  = GetExtKey(SecretSalt, SecretPW);
                ExtKey masterKeyD = masterKey.Derive(GetCurrencyIndex("btc"), hardened: true);
                ExtKey key        = masterKeyD.Derive((uint)0);
                byte[] keybytes   = key.PrivateKey.ToBytes();
                Key    pkey       = new Key(keybytes, -1, false);
                var    address    = pkey.PubKey.GetAddress(GetBLKNetworkAlt("btc")).ToString();
                if (address != firstaddress)
                {
                    Sclear.EraseBytes(keybytes);
                    masterKey  = null;
                    masterKeyD = null;
                    key        = null;
                    pkey       = null;
                    return(null);
                }
                ExtKey masterKeyA = masterKey.Derive(GetCurrencyIndex(currencySymbol), hardened: true);
                key      = masterKeyA.Derive((uint)hdIndex);
                keybytes = key.PrivateKey.ToBytes();

                if (GetBLKNetworkAlt(currencySymbol) != null)
                {
                    BitfiWallet.AltCoinGen altCoinGen = new BitfiWallet.AltCoinGen(GetBLKNetworkAlt(currencySymbol));
                    address = altCoinGen.GetNewAddress(keybytes, DoSegwit);
                }
                else
                {
                    if (currencySymbol == "apl")
                    {
                        APLGen aPL = new APLGen();
                        address = aPL.GetPublicKey(keybytes);
                    }



                    if (currencySymbol == "xrp" && hdIndex == 0)
                    {
                        RipGen ripGen = new RipGen();
                        address = ripGen.GetAddress(keybytes);
                    }
                }

                Sclear.EraseBytes(keybytes);
                masterKey  = null;
                masterKeyD = null;
                masterKeyA = null;
                key        = null;
                pkey       = null;

                return(address);
            }
            catch
            {
                return(null);
            }
        }
        internal NEOTaskTransferResponse NEO_ClaimGas(int[] SecretSalt, int[] SecretPW, BitfiWallet.NOXWS.NoxGasRequests req)
        {
            NEOTaskTransferResponse taskTransferResponse = new NEOTaskTransferResponse();

            byte[] bts   = Convert.FromBase64String(req.NXTxn);
            string jData = System.Text.Encoding.UTF8.GetString(bts);
            NEONeoscanUnclaimed unclaimed = JsonConvert.DeserializeObject <NEONeoscanUnclaimed>(jData);

            if (unclaimed == null)
            {
                taskTransferResponse.Error = "Error, no claimable values.";
                return(taskTransferResponse);
            }
            if (unclaimed.claimable == null)
            {
                taskTransferResponse.Error = "Error, no claimable values.";
                return(taskTransferResponse);
            }

            List <NeoGasLibrary.NeoAPI.ClaimEntry> claims = new List <NeoGasLibrary.NeoAPI.ClaimEntry>();

            foreach (var un in unclaimed.claimable)
            {
                NeoGasLibrary.NeoAPI.ClaimEntry entry = new NeoGasLibrary.NeoAPI.ClaimEntry();
                entry.index = UInt16.Parse(un.n.ToString());
                entry.txid  = un.txid;
                entry.value = un.unclaimed;
                claims.Add(entry);
            }

            if (claims.Count < 1)
            {
                taskTransferResponse.Error = "Error, no claimable values.";
                return(taskTransferResponse);
            }

            byte[] keybytes = HDDerriveKey(SecretSalt, SecretPW, 0, "neo");
            var    keypair  = new NeoGasLibrary.KeyPair(keybytes);

            Sclear.EraseBytes(keybytes);
            string neoaddress = keypair.address;

            if (neoaddress.ToUpper() != req.NeoAddress.ToUpper())
            {
                keypair.Dispose();
                taskTransferResponse.Error = "Invalid information.";
                return(taskTransferResponse);
            }


            var tx    = NeoGasLibrary.NeoAPI.BuildClamTx(claims, NeoGasLibrary.NeoAPI.Net.Main, keypair.address);
            var txHex = NeoGasLibrary.NeoAPI.SignAndSerialize(tx, keypair);

            keypair.Dispose();
            taskTransferResponse.TxnHex = txHex;
            return(taskTransferResponse);
        }
        //TRANSACTIONS



        internal NEOTaskTransferResponse NEO_Sign(int[] SecretSalt, int[] SecretPW, string MXTxn, string BlkNet, string ToAddress, string Amount, string FromAddress)
        {
            NEOTaskTransferResponse taskTransferResponse = new NEOTaskTransferResponse();

            try
            {
                byte[] bts   = Convert.FromBase64String(MXTxn);
                string jData = System.Text.Encoding.UTF8.GetString(bts);
                NEONeoscanUnspent[] unspent = JsonConvert.DeserializeObject <NEONeoscanUnspent[]>(jData);
                if (unspent == null || unspent.Length < 1)
                {
                    taskTransferResponse.Error = "No unspent.";
                    return(taskTransferResponse);
                }
                List <NeoGasLibrary.NeoAPI.UnspentEntry> entries = new List <NeoGasLibrary.NeoAPI.UnspentEntry>();
                foreach (var un in unspent)
                {
                    NeoGasLibrary.NeoAPI.UnspentEntry entry = new NeoGasLibrary.NeoAPI.UnspentEntry();
                    entry.index = UInt16.Parse(un.n.ToString());
                    entry.txid  = un.txid;
                    entry.value = un.value;
                    entries.Add(entry);
                }
                if (entries == null || entries.Count < 1)
                {
                    taskTransferResponse.Error = "No Entries.";
                    return(taskTransferResponse);
                }

                byte[] keybytes = HDDerriveKey(SecretSalt, SecretPW, 0, "neo");
                var    assetId  = BlkNet.ToLower() == "gas" ? NeoGasLibrary.NeoAPI.gasId : NeoGasLibrary.NeoAPI.neoId;
                NeoGasLibrary.NeoAPI.Transaction tx      = NeoGasLibrary.NeoAPI.BuildContractTx(entries, 0, FromAddress, ToAddress, Amount, assetId);
                NeoGasLibrary.KeyPair            keypair = new NeoGasLibrary.KeyPair(keybytes);
                Sclear.EraseBytes(keybytes);
                string neoaddress = keypair.address;
                if (neoaddress != FromAddress)
                {
                    keypair.Dispose();
                    taskTransferResponse.Error = "Invalid information.";
                    return(taskTransferResponse);
                }

                string txHex = NeoGasLibrary.NeoAPI.SignAndSerialize(tx, keypair);
                taskTransferResponse.TxnHex = txHex;
                taskTransferResponse.Error  = "";
                keypair.Dispose();
                return(taskTransferResponse);
            }
            catch (Exception ex)
            {
                taskTransferResponse.Error = "Error: " + ex.Message;
                return(taskTransferResponse);
            }
        }
Ejemplo n.º 9
0
 private string GetFirstNEO(ExtKey masterKey)
 {
     ExtKey masterKeyA = masterKey.Derive(GetCurrencyIndex("neo"), hardened: true);
     ExtKey key = masterKeyA.Derive((uint)0);
     byte[] keybytes = key.PrivateKey.ToBytes();
     var NEOkeypair = new KeyPair(keybytes);
     string neoaddress = NEOkeypair.address;
     Sclear.EraseBytes(keybytes);
     masterKeyA = null;
     key = null;
     NEOkeypair.Dispose();
     return neoaddress;
 }
Ejemplo n.º 10
0
 private string GetFirstETH(ExtKey masterKey)
 {
     ExtKey masterKeyA = masterKey.Derive(GetCurrencyIndex("eth"), hardened: true);
     ExtKey key = masterKeyA.Derive((uint)0);
     byte[] keybytes = key.PrivateKey.ToBytes();
     EthECKey ETHkey = new EthECKey(keybytes, true);
     string ethadr = ETHkey.GetPublicAddress();
     Sclear.EraseBytes(keybytes);
     masterKeyA = null;
     key = null;
     ETHkey = null;
     return ethadr;
 }
Ejemplo n.º 11
0
 private string GetFirstLTC(ExtKey masterKey)
 {
     ExtKey masterKeyA = masterKey.Derive(GetCurrencyIndex("ltc"), hardened: true);
     ExtKey key = masterKeyA.Derive((uint)0);
     byte[] keybytes = key.PrivateKey.ToBytes();
     Key pkey = new Key(keybytes, -1, false);
     var resp = pkey.PubKey.GetAddress(GetBLKNetworkAlt("ltc")).ToString();
     Sclear.EraseBytes(keybytes);
     masterKeyA = null;
     key = null;
     pkey = null;
     return resp;
 }
        private ExtKey GetExtKey(int[] SecretSalt, int[] SecretPW)
        {
            byte[] ssalt = new byte[SecretSalt.Length];
            for (int i = 0; i < SecretSalt.Length; i++)
            {
                ssalt[i]      = Sclear.SCharImage(SecretSalt[i]).SBYTE;
                SecretSalt[i] = -1;
            }

            byte[] spw = new byte[SecretPW.Length];
            for (int i = 0; i < SecretPW.Length; i++)
            {
                spw[i]      = Sclear.SCharImage(SecretPW[i]).SBYTE;
                SecretPW[i] = -1;
            }

            byte[] der = NBitcoin.Crypto.SCrypt.ComputeDerivedKey(spw, ssalt, 32768, 8, 4, 4, 64);

            if (der == null)
            {
                throw new Exception("Error, invalid info.");
            }

            if (!string.IsNullOrEmpty(Sclear.LastHashAtp))
            {
                using (var Tshacrypt = new System.Security.Cryptography.SHA256Managed())
                {
                    byte[] Thash = Tshacrypt.ComputeHash(der);
                    string tval  = Convert.ToBase64String(Thash);
                    if (tval != Sclear.LastHashAtp)
                    {
                        throw new Exception("Information does not match.");
                    }
                    Sclear.LastHashAtp = null;
                }
            }

            using (var shacrypt = new System.Security.Cryptography.SHA256Managed())
            {
                byte[] hash      = shacrypt.ComputeHash(ssalt);
                ExtKey masterKey = new ExtKey(der, hash);
                Sclear.Clear(SecretSalt);
                Sclear.Clear(SecretPW);
                Sclear.EraseBytes(ssalt);
                Sclear.EraseBytes(spw);
                Sclear.EraseBytes(der);
                Sclear.Clear(hash);

                return(masterKey);
            }
        }
        internal ETHTaskTransferResponse ETH_Sign(int[] SecretSalt, int[] SecretPW, BitfiWallet.NOXWS.NoxTxnProcess tproc)
        {
            ETHTaskTransferResponse taskTransferResponse = new ETHTaskTransferResponse();

            byte[] keybytes = HDDerriveKey(SecretSalt, SecretPW, 0, "eth");

            EthECKey key = new EthECKey(keybytes, true);

            Sclear.EraseBytes(keybytes);

            string ethadr = key.GetPublicAddress();

            if (ethadr != tproc.NoxAddress.BTCAddress)
            {
                taskTransferResponse.Error = "Invalid information.";
                return(taskTransferResponse);
            }


            //TO DO
            if (tproc.ETCToken != null)
            {
                var contractAddress = tproc.ETCToken.EnsureHexPrefix();
                var to       = tproc.ToAddress.EnsureHexPrefix();
                var amount   = NumUtils.Utils.ParseMoney(tproc.Amount, 18);
                var nonce    = System.Numerics.BigInteger.Parse(tproc.ETCNonce);
                var gasPrice = NumUtils.Utils.ParseMoney(tproc.FeeValue, 18);
                var gasLimit = new System.Numerics.BigInteger(Int64.Parse(tproc.ETCGasUsed));
                var tx       = new EthereumLibrary.Signer.Transaction(contractAddress, to, amount, nonce, gasPrice, gasLimit);
                tx.Sign(key);
                var signedHex = tx.ToHex();
                key = null;
                taskTransferResponse.TxnHex = signedHex;
                return(taskTransferResponse);
            }
            else
            {
                var to       = tproc.ToAddress.EnsureHexPrefix();
                var amount   = NumUtils.Utils.ParseMoney(tproc.Amount, 18);
                var nonce    = System.Numerics.BigInteger.Parse(tproc.ETCNonce);
                var gasPrice = NumUtils.Utils.ParseMoney(tproc.FeeValue, 18);
                var gasLimit = new System.Numerics.BigInteger(Int64.Parse(tproc.ETCGasUsed));

                var tx = new EthereumLibrary.Signer.Transaction(to, amount, nonce, gasPrice, gasLimit);
                tx.Sign(key);
                var signedHex = tx.ToHex();
                key = null;
                taskTransferResponse.TxnHex = signedHex;
                return(taskTransferResponse);
            }
        }
Ejemplo n.º 14
0
        private string[] GetFirstXMR(ExtKey masterKey)
        {
            ExtKey masterKeyA = masterKey.Derive(GetCurrencyIndex("xmr"), hardened: true);
            ExtKey key = masterKeyA.Derive((uint)0);
            byte[] keybytes = key.PrivateKey.ToBytes();
            MoneroWallet.Wallet wallet = MoneroWallet.Wallet.OpenWallet(keybytes);
            string[] moneroadr = { wallet.Address, MoneroWallet.Converters.ByteArrayToHex(wallet.Keys.ViewSecret) };
            Sclear.EraseBytes(keybytes);
            masterKeyA = null;
            key = null;
            wallet.Dispose();

            return moneroadr;
        }
Ejemplo n.º 15
0
        internal string[] SignSGAMessageOut(int[] SecretSalt, int[] SecretPW, string sgaMessage)
        {
            try
            {
                ExtKey masterKey = GetExtKey(SecretSalt, SecretPW);

                ExtKey masterKeyD = masterKey.Derive(GetCurrencyIndex("btc"), hardened: true);
                ExtKey key = masterKeyD.Derive((uint)0);
                byte[] keybytes = key.PrivateKey.ToBytes();

                Key pkey = new Key(keybytes, -1, false);
                BitcoinSecret bitcoinSecret = new BitcoinSecret(pkey, Network.Main);
                var address = bitcoinSecret.PubKey.GetAddress(GetBLKNetworkAlt("btc")).ToString();
                var signature = bitcoinSecret.PrivateKey.SignMessage(sgaMessage);
                Sclear.EraseBytes(keybytes);

                masterKeyD = null;

                key = null;
                pkey = null;
                NWS WS = new NWS();
                List\\ lnoxAddresses = new List\\();
                string adrlist = JsonConvert.SerializeObject(lnoxAddresses);
                string tkmsg = WS.GetSGAToken(address, signature);
                if (tkmsg.Length \                {
                    return new string[2] { tkmsg, adrlist };
                }

                var objaddrListindexes = WS.GetAddressIndexes(tkmsg);
                if (objaddrListindexes != null)
                {
                    lnoxAddresses = GetReviewIndexes(objaddrListindexes, masterKey);
                    adrlist = JsonConvert.SerializeObject(lnoxAddresses);
                }
                else
                {
                    tkmsg = "1";
                }
                return new string[2] { tkmsg, adrlist };
            }
            catch
            {
                return new string[2] { "4", "" };
            }
        }
        internal XMRTaskTransferResponse XMR_Sign(int[] SecretSalt, int[] SecretPW, string ToAddress, string Amount, string BaseData, string FromAddress)
        {
            XMRTaskTransferResponse taskTransferResponse = new XMRTaskTransferResponse();

            byte[] keybytes = HDDerriveKey(SecretSalt, SecretPW, 0, "xmr");

            try
            {
                byte[] bts   = Convert.FromBase64String(BaseData);
                string jData = System.Text.Encoding.UTF8.GetString(bts);
                JsonSerializerSettings ser = new JsonSerializerSettings();
                ser.MissingMemberHandling  = MissingMemberHandling.Ignore;
                ser.NullValueHandling      = NullValueHandling.Ignore;
                ser.ObjectCreationHandling = ObjectCreationHandling.Auto;
                ser.TypeNameHandling       = TypeNameHandling.All;
                var data = JsonConvert.DeserializeObject <MoneroWallet.LedgerData>(jData, ser);
                var wlt  = MoneroWallet.Wallet.OpenWallet(keybytes);
                Sclear.EraseBytes(keybytes);
                if (wlt.Address != FromAddress)
                {
                    wlt.Dispose();
                    taskTransferResponse.Error = "Invalid information.";
                    return(taskTransferResponse);
                }

                BitfiWallet.XMRGen xMRGen = new BitfiWallet.XMRGen(wlt);
                var send = xMRGen.XMR_Sign(ToAddress, Amount, BaseData, FromAddress);

                taskTransferResponse.Error          = send.Error;
                taskTransferResponse.SpendKeyImages = send.SpendKeyImages;
                taskTransferResponse.TxnHex         = send.TxnHex;
                wlt.Dispose();

                if (string.IsNullOrEmpty(taskTransferResponse.Error))
                {
                }

                return(taskTransferResponse);
            }
            catch (Exception ex)
            {
                taskTransferResponse.Error = ex.Message;
                return(taskTransferResponse);
            }
        }
        internal MsgTaskTransferResponse SignUserMsg(int[] SecretSalt, int[] SecretPW, BitfiWallet.NOXWS.NoxMsgProcess req)
        {
            MsgTaskTransferResponse msgTaskTransferResponse = new MsgTaskTransferResponse();

            try
            {
                byte[] Msg      = Convert.FromBase64String(req.Msg);
                byte[] keybytes = HDDerriveKey(SecretSalt, SecretPW, req.NoxAddress.HDIndex, req.BlkNet);

                if (req.BlkNet == "eth")
                {
                    EthECKey ekey = new EthECKey(keybytes, true);

                    string ethadr = ekey.GetPublicAddress();
                    if (ethadr != req.NoxAddress.BTCAddress)
                    {
                        msgTaskTransferResponse.Error = "Invalid information.";
                    }
                    else
                    {
                        EthereumLibrary.MsgSigning elib = new EthereumLibrary.MsgSigning();
                        msgTaskTransferResponse.MsgSig = elib.ETHMsgSign(Msg, ekey);
                    }
                }
                else
                {
                    BitfiWallet.AltCoinGen altCoinGen = new BitfiWallet.AltCoinGen(GetBLKNetworkAlt(req.BlkNet));
                    msgTaskTransferResponse.MsgSig = altCoinGen.AltMsgSign(keybytes, req.NoxAddress.BTCAddress, System.Text.Encoding.UTF8.GetString(Msg));
                }



                Sclear.EraseBytes(keybytes);
                return(msgTaskTransferResponse);
            }
            catch (Exception ex)
            {
                msgTaskTransferResponse.Error = ex.Message;
                return(msgTaskTransferResponse);
            }
        }
Ejemplo n.º 18
0
        internal List\\ GetReviewIndexes(BitfiWallet.SGADWS.NoxAddressReviewV3 noxAddressReviews, ExtKey masterKey)
        {
            List\\ noxAddresses = new List\\();

            foreach (var adrReview in noxAddressReviews.AdrReview)
            {
                string currencySymbol = adrReview.Blk;
                ExtKey ASmasterKey = masterKey.Derive(GetCurrencyIndex(currencySymbol), hardened: true);


                for (int i = 0; i \                {

                    string address = "";
                    ExtKey key = ASmasterKey.Derive((uint)i);
                    byte[] keybytes = key.PrivateKey.ToBytes();

                    if (GetBLKNetworkAlt(adrReview.Blk) != null)
                    {

                        foreach(var nadr in noxAddressReviews.Addresses)
                        {
                            if (nadr.BlkNet == adrReview.Blk && nadr.HDIndex == i)
                            {
                                BitfiWallet.AltCoinGen altCoinGen = new BitfiWallet.AltCoinGen(GetBLKNetworkAlt(adrReview.Blk));
                                address = altCoinGen.GetNewAddress(keybytes, nadr.DoSegwit);
                                break;
                            }
                        }


                    }
                    if (adrReview.Blk == "apl")
                    {
                        APLGen aPL = new APLGen();
                        address =  aPL.GetAccountID(keybytes);
                    }
                    if (adrReview.Blk == "neo")
                    {
                         var NEOkeypair = new KeyPair(keybytes);
                        address = NEOkeypair.address;
                        NEOkeypair.Dispose();
                    }
                    if (adrReview.Blk == "xmr")
                    {
                        MoneroWallet.Wallet wallet = MoneroWallet.Wallet.OpenWallet(keybytes);
                        address = wallet.Address;
                        wallet.Dispose();

                    }
                    if (adrReview.Blk == "eth")
                    {
                        EthECKey ETHkey = new EthECKey(keybytes, true);
                        address = ETHkey.GetPublicAddress();
                    }
                    if (adrReview.Blk == "xrp")
                    {
                        RipGen ripGen = new RipGen();
                        address = ripGen.GetAddress(keybytes);
                    }
                    Sclear.EraseBytes(keybytes);
                    key = null;

                    noxAddresses.Add(new BitfiWallet.NOXWS.NoxAddresses { BlkNet = currencySymbol, BTCAddress = address}

                    );

                }

            }
            masterKey = null;

            return noxAddresses;
        }