public static EcKey CreateEcKeyFromHexString(string privateKey) { var pkey = new BigInteger(privateKey, 16); var key = new EcKey(pkey); return(key); }
public static EcKey createEcKeyFromHexString(String privateKey) { BigInteger pkey = new BigInteger(privateKey, 16); EcKey key = new EcKey(pkey); return(key); }
public static String deriveSIN(EcKey ecKey) { // Get sha256 hash and then the RIPEMD-160 hash of the public key (this call gets the result in one step). byte[] pubKeyHash = ecKey.PubKeyHash; // Convert binary pubKeyHash, SINtype and version to Hex String version = "0F"; String SINtype = "02"; String pubKeyHashHex = bytesToHex(pubKeyHash); // Concatenate all three elements String preSIN = version + SINtype + pubKeyHashHex; // Convert the hex string back to binary and double sha256 hash it leaving in binary both times byte[] preSINbyte = hexToBytes(preSIN); byte[] hash2Bytes = Utils.DoubleDigest(preSINbyte); // Convert back to hex and take first four bytes String hashString = bytesToHex(hash2Bytes); String first4Bytes = hashString.Substring(0, 8); // Append first four bytes to fully appended SIN string String unencoded = preSIN + first4Bytes; byte[] unencodedBytes = new BigInteger(unencoded, 16).ToByteArray(); String encoded = Base58.Encode(unencodedBytes); return(encoded); }
public static void saveEcKey(EcKey ecKey) { byte[] bytes = ecKey.ToAsn1(); FileStream fs = new FileStream(GetPrivateKeyFullName(), FileMode.Create, FileAccess.Write); fs.Write(bytes, 0, bytes.Length); fs.Close(); }
public static void saveEcKey(EcKey ecKey, string path) { byte[] bytes = ecKey.ToAsn1(); FileStream fs = new FileStream(path, FileMode.Create, FileAccess.Write); fs.Write(bytes, 0, bytes.Length); fs.Close(); }
public static void saveEcKey(EcKey ecKey) { byte[] bytes = ecKey.ToAsn1(); FileStream fs = new FileStream(PRIV_KEY_FILENAME, FileMode.Create, FileAccess.Write); fs.Write(bytes, 0, bytes.Length); fs.Close(); }
public static async Task <EcKey> LoadEcKey() { using (var fs = File.OpenRead(PrivateKeyFilename)) { var b = new byte[1024]; await fs.ReadAsync(b, 0, b.Length); var key = EcKey.FromAsn1(b); return(key); } }
/// <summary> /// Signs the input string with the provided key /// </summary> /// <param name="ecKey">The key object to sign with</param> /// <param name="input">The string to be signed</param> /// <returns>The signature</returns> public static string Sign(EcKey ecKey, string input) { // return ecKey.Sign(input); var hash = Sha256Hash(input); var hashBytes = HexToBytes(hash); var signature = ecKey.Sign(hashBytes); var bytesHex = BytesToHex(signature); return(bytesHex); }
public static EcKey loadEcKey() { using (FileStream fs = File.OpenRead(GetPrivateKeyFullName())) { byte[] b = new byte[1024]; fs.Read(b, 0, b.Length); EcKey key = EcKey.FromAsn1(b); return(key); } }
public static EcKey loadEcKey(string path) { using (FileStream fs = File.OpenRead(path)) { byte[] b = new byte[1024]; fs.Read(b, 0, b.Length); EcKey key = EcKey.FromAsn1(b); return(key); } }
public static EcKey loadEcKey() { using (FileStream fs = File.OpenRead(PRIV_KEY_FILENAME)) { byte[] b = new byte[1024]; fs.Read(b, 0, b.Length); EcKey key = EcKey.FromAsn1(b); return(key); } }
/// <summary> /// Constructor for use if the keys and SIN were derived external to this library. /// </summary> /// <param name="ecKey">An elliptical curve key.</param> /// <param name="clientName">The label for this client.</param> /// <param name="envUrl">The target server URL.</param> public BitPay(EcKey ecKey, String clientName = BITPAY_PLUGIN_INFO, String envUrl = BITPAY_URL) { // IgnoreBadCertificates(); _ecKey = ecKey; this.deriveIdentity(); _baseUrl = envUrl; _httpClient = new HttpClient(); _httpClient.BaseAddress = new Uri(_baseUrl); this.tryGetAccessTokens(); }
public static async Task SaveEcKey(EcKey ecKey) { var bytes = ecKey.ToAsn1(); if (!Directory.Exists(BitPay.TokensFolder)) { Directory.CreateDirectory(BitPay.TokensFolder); } using (var fs = new FileStream(PrivateKeyFilename, FileMode.Create, FileAccess.Write)) { await fs.WriteAsync(bytes, 0, bytes.Length); } }
/// <summary> /// Initialize the public/private key pair by either loading the existing one or by creating a new one /// </summary> /// <returns></returns> private async Task InitKeys() { if (KeyUtils.PrivateKeyExists(_configuration.GetSection("BitPayConfiguration:EnvConfig:" + _env + ":PrivateKeyPath").Value)) { _ecKey = await KeyUtils.LoadEcKey(); } else { _ecKey = KeyUtils.CreateEcKey(); await KeyUtils.SaveEcKey(_ecKey); } }
public static async Task SaveEcKey(EcKey ecKey) { var bytes = ecKey.ToAsn1(); if (!string.IsNullOrEmpty(Path.GetDirectoryName(PrivateKeyFile)) && !Directory.Exists(Path.GetDirectoryName(PrivateKeyFile))) { Directory.CreateDirectory(Path.GetDirectoryName(PrivateKeyFile)); } using (var fs = new FileStream(PrivateKeyFile, FileMode.Create, FileAccess.Write)) { await fs.WriteAsync(bytes, 0, bytes.Length); } }
private void initKeys() { if (KeyUtils.privateKeyExists()) { _ecKey = KeyUtils.loadEcKey(); // Alternatively, load your private key from a location you specify. //_ecKey = KeyUtils.createEcKeyFromHexStringFile("C:\\Users\\Andy\\Documents\\private-key.txt"); } else { _ecKey = KeyUtils.createEcKey(); KeyUtils.saveEcKey(_ecKey); } }
/// <summary> /// Initialize the public/private key pair by either loading the existing one or by creating a new one /// </summary> /// <returns></returns> private async Task InitKeys() { if (KeyUtils.PrivateKeyExists()) { _ecKey = await KeyUtils.LoadEcKey(); // TODO: Alternatively, load your private key from a location you specify. //_ecKey = KeyUtils.createEcKeyFromHexStringFile("C:\\Users\\Andy\\Documents\\private-key.txt"); } else { _ecKey = KeyUtils.CreateEcKey(); await KeyUtils.SaveEcKey(_ecKey); } }
private void initKeys() { string path = HttpContext.Current.Server.MapPath("~/App_Start/bitpay_private.key"); if (KeyUtils.privateKeyExists(path)) { _ecKey = KeyUtils.loadEcKey(path); // Alternatively, load your private key from a location you specify. //_ecKey = KeyUtils.createEcKeyFromHexStringFile(path); } else { _ecKey = KeyUtils.createEcKey(); KeyUtils.saveEcKey(_ecKey, path); } }
public static string DeriveSin(EcKey ecKey) { if (_derivedSin != null) { return(_derivedSin); } // Get sha256 hash and then the RIPEMD-160 hash of the public key (this call gets the result in one step). var pubKey = ecKey.PublicKey; var hash = new SHA256Managed().ComputeHash(pubKey); var ripeMd160Digest = new RipeMD160Digest(); ripeMd160Digest.BlockUpdate(hash, 0, hash.Length); var output = new byte[20]; ripeMd160Digest.DoFinal(output, 0); var pubKeyHash = output; // Convert binary pubKeyHash, SINtype and version to Hex var version = "0F"; var siNtype = "02"; var pubKeyHashHex = BytesToHex(pubKeyHash); // Concatenate all three elements var preSin = version + siNtype + pubKeyHashHex; // Convert the hex string back to binary and double sha256 hash it leaving in binary both times var preSiNbyte = HexToBytes(preSin); var hash2Bytes = DoubleDigest(preSiNbyte); // Convert back to hex and take first four bytes var hashString = BytesToHex(hash2Bytes); var first4Bytes = hashString.Substring(0, 8); // Append first four bytes to fully appended SIN string var unencoded = preSin + first4Bytes; var unencodedBytes = new BigInteger(unencoded, 16).ToByteArray(); var encoded = Encode(unencodedBytes); _derivedSin = encoded; return(encoded); }
public static void saveEcKey(EcKey ecKey) { saveEcKey(ecKey, PRIV_KEY_FILENAME); }
public static String sign(EcKey ecKey, String input) { String hash = sha256Hash(input); return(bytesToHex(ecKey.Sign(hexToBytes(hash)))); }
/// <summary> /// Constructor for use if the keys and SIN were derived external to this library. /// </summary> /// <param name="ecKey">An elliptical curve key.</param> /// <param name="clientName">The label for this client.</param> /// <param name="envUrl">The target server URL.</param> public BitPay(EcKey ecKey, string clientName = BitpayPluginInfo, string envUrl = BitpayUrl) { _ecKey = ecKey; Init(clientName, envUrl).Wait(); }