public WalletManager(IWalletManagerConfig config, ISignatureFactory signatureFactory, IHashFactory hashFactory) { this.config = config; this.signatureFactory = signatureFactory; this.hashFactory = hashFactory; wallets = new LinkedList <Wallet>(); foreach (string walletPath in Directory.GetFiles(config.WalletDirectoryPath, "*.wallet")) { JsonSerializer serializer = new JsonSerializer(); byte[] walletBlob; using (Stream jsonFile = File.Open(walletPath, FileMode.Open, FileAccess.Read, FileShare.None)) using (StreamReader reader = new StreamReader(jsonFile)) using (JsonReader jsonReader = new JsonTextReader(reader)) walletBlob = serializer.Deserialize <byte[]>(jsonReader); ISignatureProvider signer = signatureFactory.GetSignatureProvider(walletBlob); Wallet wallet = new Wallet(signer, hashFactory); wallets.Add(wallet); } }
/// <summary> /// Parses a JWT string encoded. /// </summary> /// <param name="token">The access token.</param> /// <param name="algorithm">The signature algorithm.</param> /// <param name="verify">true if verify the signature; otherwise, false.</param> /// <returns>A JSON web token object.</returns> /// <exception cref="ArgumentNullException">token was null. -or- algorithm was null and verify is true.</exception> /// <exception cref="ArgumentException">token is not a Bearer token, or its access token did not contain the required information.</exception> /// <exception cref="FormatException">The access token was in incorrect format.</exception> /// <exception cref="InvalidOperationException">Verify failure.</exception> public static JsonWebToken <T> Parse(TokenInfo token, ISignatureProvider algorithm, bool verify = true) { if (token == null) { throw new ArgumentNullException(nameof(token), "token should not be null."); } if (string.IsNullOrWhiteSpace(token.AccessToken)) { throw new ArgumentException("The access token should not be null or empty.", nameof(token)); } if (!string.IsNullOrEmpty(token.TokenType) && token.TokenType != TokenInfo.BearerTokenType) { throw new ArgumentException("The token type should be Bearer.", nameof(token)); } try { return(Parse(token.AccessToken, algorithm, verify)); } catch (ArgumentException ex) { var msg = string.IsNullOrWhiteSpace(ex.Message) || ex.Message.Length < 7 || ex.Message.IndexOf("jwt ") != 0 ? "The access token is incorrect." : ("The access token" + ex.Message.Substring(3)); throw new ArgumentException(msg, nameof(token), ex); } }
public iDealResponse HandleResponse(string response, ISignatureProvider signatureProvider) { var xDocument = XElement.Parse(response); switch (xDocument.Name.LocalName) { case "DirectoryRes": return new DirectoryResponse(response); case "AcquirerTrxRes": return new TransactionResponse(response); case "AcquirerStatusRes": var statusResponse = new StatusResponse(response); // Check fingerprint if (statusResponse.Fingerprint != signatureProvider.GetThumbprintAcquirerCertificate()) throw new SecurityException("Signature fingerprint from status respone does not match fingerprint acquirer's certificate"); // Check digital signature if (!signatureProvider.VerifySignature(statusResponse.SignatureValue, statusResponse.MessageDigest)) throw new SecurityException("Signature status response from acquirer's certificate is not valid"); return statusResponse; case "ErrorRes": throw new iDealException(xDocument); default: throw new InvalidDataException("Unknown response"); } }
public override string ToXml(ISignatureProvider signatureProvider) { XNamespace xmlNamespace = "http://www.idealdesk.com/ideal/messages/mer-acq/3.3.1"; var directoryRequestXmlMessage = new XDocument( new XDeclaration("1.0", "UTF-8", null), new XElement(xmlNamespace + "AcquirerTrxReq", new XAttribute("version", "3.3.1"), new XElement(xmlNamespace + "createDateTimestamp", createDateTimestamp), new XElement(xmlNamespace + "Issuer", new XElement(xmlNamespace + "issuerID", IssuerId.ToString().PadLeft(4, '0')) ), new XElement(xmlNamespace + "Merchant", new XElement(xmlNamespace + "merchantID", MerchantId.PadLeft(9, '0')), new XElement(xmlNamespace + "subID", "0"), new XElement(xmlNamespace + "merchantReturnURL", MerchantReturnUrl) ), new XElement(xmlNamespace + "Transaction", new XElement(xmlNamespace + "purchaseID", PurchaseId), new XElement(xmlNamespace + "amount", Amount), new XElement(xmlNamespace + "currency", "EUR"), new XElement(xmlNamespace + "expirationPeriod", "PT" + Convert.ToInt32(Math.Floor(ExpirationPeriod.Value.TotalSeconds)) + "S"), new XElement(xmlNamespace + "language", "nl"), new XElement(xmlNamespace + "description", Description), new XElement(xmlNamespace + "entranceCode", EntranceCode) ) ) ); return(signatureProvider.SignXml(directoryRequestXmlMessage)); }
public iDealResponse HandleResponse(string response, ISignatureProvider signatureProvider) { var xDocument = XElement.Parse(response); if (!signatureProvider.VerifySignature(response)) { throw new InvalidSignatureException(); } switch (xDocument.Name.LocalName) { case "DirectoryRes": return new DirectoryResponse(response); case "AcquirerTrxRes": return new TransactionResponse(response); case "AcquirerStatusRes": var statusResponse = new StatusResponse(response); return statusResponse; case "AcquirerErrorRes": throw new iDealException(xDocument); default: throw new InvalidDataException("Unknown response"); } }
public override string ToXml(ISignatureProvider signatureProvider) { XNamespace xmlNamespace = "http://www.idealdesk.com/Message"; var directoryRequestXmlMessage = new XDocument( new XDeclaration("1.0", "UTF-8", null), new XElement(xmlNamespace + "AcquirerTrxReq", new XAttribute("version", "1.1.0"), new XElement(xmlNamespace + "createDateTimeStamp", CreateDateTimeStamp), new XElement(xmlNamespace + "Issuer", new XElement(xmlNamespace + "issuerID", IssuerId.ToString().PadLeft(4, '0')) ), new XElement(xmlNamespace + "Merchant", new XElement(xmlNamespace + "merchantID", MerchantId.PadLeft(9, '0')), new XElement(xmlNamespace + "subID", MerchantSubId), new XElement(xmlNamespace + "authentication", "SHA1_RSA"), new XElement(xmlNamespace + "token", signatureProvider.GetThumbprintAcceptantCertificate()), new XElement(xmlNamespace + "tokenCode", signatureProvider.GetSignature(MessageDigest)), new XElement(xmlNamespace + "merchantReturnURL", MerchantReturnUrl) ), new XElement(xmlNamespace + "Transaction", new XElement(xmlNamespace + "purchaseID", PurchaseId), new XElement(xmlNamespace + "amount", Amount), new XElement(xmlNamespace + "currency", "EUR"), new XElement(xmlNamespace + "expirationPeriod", "PT" + Convert.ToInt32(Math.Floor(ExpirationPeriod.Value.TotalSeconds)) + "S"), new XElement(xmlNamespace + "language", "nl"), new XElement(xmlNamespace + "description", Description), new XElement(xmlNamespace + "entranceCode", EntranceCode) ) ) ); return(directoryRequestXmlMessage.Declaration + directoryRequestXmlMessage.ToString(SaveOptions.None)); }
public iDealResponse SendRequest(iDealRequest idealRequest, ISignatureProvider signatureProvider, string url, IiDealHttpResponseHandler iDealHttpResponseHandler) { ServicePointManager.ServerCertificateValidationCallback = ((sender, certificate, chain, sslPolicyErrors) => true); // Create request var request = (HttpWebRequest) WebRequest.Create(url); request.ProtocolVersion = HttpVersion.Version11; request.ContentType = "text/xml"; request.Method = "POST"; // request.Proxy = new WebProxy("192.168.1.8", 8080); // Set content string xml = idealRequest.ToXml(signatureProvider); byte[] postBytes = Encoding.ASCII.GetBytes(xml); // Send using (Stream requestStream = request.GetRequestStream()) { requestStream.Write(postBytes, 0, postBytes.Length); } // Return result using (WebResponse response = request.GetResponse()) { using (var reader = new StreamReader(response.GetResponseStream())) { return iDealHttpResponseHandler.HandleResponse(reader.ReadToEnd(), signatureProvider); } } }
public override string ToXml(ISignatureProvider signatureProvider) { XNamespace xmlNamespace = "http://www.idealdesk.com/Message"; var directoryRequestXmlMessage = new XDocument( new XDeclaration("1.0", "UTF-8", null), new XElement(xmlNamespace + "AcquirerStatusReq", new XAttribute("version", "1.1.0"), new XElement(xmlNamespace + "createDateTimeStamp", CreateDateTimeStamp), new XElement(xmlNamespace + "Merchant", new XElement(xmlNamespace + "merchantID", MerchantId.PadLeft(9, '0')), new XElement(xmlNamespace + "subID", MerchantSubId), new XElement(xmlNamespace + "authentication", "SHA1_RSA"), new XElement(xmlNamespace + "token", signatureProvider.GetThumbprintAcceptantCertificate()), new XElement(xmlNamespace + "tokenCode", signatureProvider.GetSignature(MessageDigest)) ), new XElement(xmlNamespace + "Transaction", new XElement(xmlNamespace + "transactionID", TransactionId) ) ) ); return(directoryRequestXmlMessage.Declaration + directoryRequestXmlMessage.ToString(SaveOptions.None)); }
internal static SignTest Create( X509Certificate2 certificate, HashAlgorithmName hashAlgorithm, byte[] package = null, ISignatureProvider signatureProvider = null) { ISignedPackage signedPackage; MemoryStream readStream = null; MemoryStream writeStream = null; if (package == null) { signedPackage = Mock.Of <ISignedPackage>(); } else { readStream = new MemoryStream(package); writeStream = new MemoryStream(); signedPackage = new SignedPackageArchive(readStream, writeStream); } signatureProvider = signatureProvider ?? Mock.Of <ISignatureProvider>(); var signer = new Signer(signedPackage, signatureProvider); var request = new SignPackageRequest(certificate, signatureHashAlgorithm: hashAlgorithm); return(new SignTest( signer, signedPackage, signatureProvider, request, readStream, writeStream)); }
public iDealResponse HandleResponse(string response, ISignatureProvider signatureProvider) { var xDocument = XElement.Parse(response); if (!signatureProvider.VerifySignature(response)) { throw new InvalidSignatureException(); } switch (xDocument.Name.LocalName) { case "DirectoryRes": return(new DirectoryResponse(response)); case "AcquirerTrxRes": return(new TransactionResponse(response)); case "AcquirerStatusRes": var statusResponse = new StatusResponse(response); return(statusResponse); case "AcquirerErrorRes": throw new iDealException(xDocument); default: throw new InvalidDataException("Unknown response"); } }
public override string ToXml(ISignatureProvider signatureProvider) { XNamespace xmlNamespace = "http://www.idealdesk.com/Message"; var directoryRequestXmlMessage = new XDocument( new XDeclaration("1.0", "UTF-8", null), new XElement(xmlNamespace + "AcquirerStatusReq", new XAttribute("version", "1.1.0"), new XElement(xmlNamespace + "createDateTimeStamp", CreateDateTimeStamp), new XElement(xmlNamespace + "Merchant", new XElement(xmlNamespace + "merchantID", MerchantId.PadLeft(9, '0')), new XElement(xmlNamespace + "subID", MerchantSubId), new XElement(xmlNamespace + "authentication", "SHA1_RSA"), new XElement(xmlNamespace + "token", signatureProvider.GetThumbprintAcceptantCertificate()), new XElement(xmlNamespace + "tokenCode", signatureProvider.GetSignature(MessageDigest)) ), new XElement(xmlNamespace + "Transaction", new XElement(xmlNamespace + "transactionID", TransactionId) ) ) ); return directoryRequestXmlMessage.Declaration + directoryRequestXmlMessage.ToString(SaveOptions.None); }
private async Task <int> SignPackageAsync( string packagePath, string outputPath, ILogger logger, bool Overwrite, ISignatureProvider signatureProvider, AuthorSignPackageRequest request, CancellationToken token) { // For overwrite we need to first remove the signature and then sign the unsigned package if (Overwrite) { var originalPackageCopyPath = CopyPackage(packagePath); await RemoveSignatureAsync(logger, signatureProvider, packagePath, originalPackageCopyPath, token); await AddSignatureAndUpdatePackageAsync(logger, signatureProvider, request, originalPackageCopyPath, outputPath, token); FileUtility.Delete(originalPackageCopyPath); } else { await AddSignatureAndUpdatePackageAsync(logger, signatureProvider, request, packagePath, outputPath, token); } return(0); }
public iDealResponse SendRequest(iDealRequest idealRequest, ISignatureProvider signatureProvider, string url, IiDealHttpResponseHandler iDealHttpResponseHandler) { System.Net.ServicePointManager.ServerCertificateValidationCallback = ((sender, certificate, chain, sslPolicyErrors) => true); // Create request var request = (HttpWebRequest)WebRequest.Create(url); request.ProtocolVersion = HttpVersion.Version11; request.ContentType = "text/xml"; request.Method = "POST"; // request.Proxy = new WebProxy("192.168.1.8", 8080); // Set content string xml = idealRequest.ToXml(signatureProvider); var postBytes = Encoding.ASCII.GetBytes(xml); // Send var requestStream = request.GetRequestStream(); requestStream.Write(postBytes, 0, postBytes.Length); requestStream.Close(); // Return result var response = (HttpWebResponse)request.GetResponse(); return(iDealHttpResponseHandler.HandleResponse(new StreamReader(response.GetResponseStream()).ReadToEnd(), signatureProvider)); }
/// <summary> /// Converts to JSON web token. /// </summary> /// <param name="algorithm">The verify signature algorithm instance.</param> /// <param name="verify">true if need verify before converting; otherwise, false.</param> /// <param name="useVerifyAlgorithmName">true if use the verify algorithm name to create the instance instead of the original one; otherwise, false.</param> /// <returns>A JSON web token instance.</returns> public JsonWebToken <T> ToToken(ISignatureProvider algorithm, bool verify = true, bool useVerifyAlgorithmName = false) { if (verify && !Verify(algorithm)) { return(null); } if (string.IsNullOrWhiteSpace(PayloadBase64Url)) { return(null); } if (useVerifyAlgorithmName) { return(algorithm == null || algorithm.CanSign ? new JsonWebToken <T>(GetPayload(), algorithm) : new JsonWebToken <T>(GetPayload(), algorithm) { signatureCache = SignatureBase64Url }); } var result = new JsonWebToken <T>(GetPayload(), algorithm) { headerBase64Url = HeaderBase64Url, signatureCache = SignatureBase64Url }; var header = headerCache; if (header != null) { result.header.AlgorithmName = header.AlgorithmName; result.header.Type = header.Type; } return(result); }
public TransactionBuilder(GXRPC rpc, ISignatureProvider provider, string chainId) { this.RPC = rpc; this.signatureProvider = provider; this.operations = new List <Operation>(); this.ChainId = chainId; }
public ClientTokenProvider( ISignatureProvider signatureProvider, string iotHubHostName, string deviceId, TimeSpan defaultTtl) : this(signatureProvider, iotHubHostName, deviceId, null, defaultTtl) { }
public KrakenClient( IOptions <KrakenClientOptions> options, ISignatureProvider signatureProvider) : base(options) { _options = options; _signatureProvider = signatureProvider; }
/// <summary> /// Initializes a new instance of the <see cref="T:gxclient.GXClient"/> class. /// </summary> /// <param name="signatureProvider">Signature provider.</param> /// /// <param name="memoProvider">Memo generator provider.</param> /// <param name="AccountName">Account name.</param> /// <param name="EntryPoint">Entry point.</param> public GXClient(ISignatureProvider signatureProvider, IMemoProvider memoProvider, String AccountName, String EntryPoint = "https://node1.gxb.io") { this.SignatureProvider = signatureProvider; this.MemoProvider = memoProvider; this.AccountName = AccountName; this.EntryPoint = EntryPoint; this.RPC = new GXRPC(this.EntryPoint); }
/** * Constructs the DOM builder for a SOAP message. * @param document * the enclosing DOM document * @param message * The <code>Message</code> model element * @param signatureProvider */ protected SoapMessageDomBuilder(XDocument document, Message message, ISignatureProvider signatureProvider) { //base(); this.document = document; this.message = message; this.signatureProvider = signatureProvider; InitializeSoap(); }
/// <summary> /// Initializes a new instance of the JwtModel class. /// </summary> /// <param name="payload">The payload.</param> /// <param name="sign">The signature provider.</param> public JsonWebToken(T payload, ISignatureProvider sign) { Payload = payload; signature = sign; header = sign != null ? new JsonWebTokenHeader { AlgorithmName = sign.Name } : JsonWebTokenHeader.NoAlgorithm; }
public BitmexApiSocketService(IBitmexAuthorization bitmexAuthorization, IExpiresTimeProvider expiresTimeProvider, ISignatureProvider signatureProvider, IBitmexApiSocketProxy bitmexApiSocketProxy) { _bitmexAuthorization = bitmexAuthorization; _expiresTimeProvider = expiresTimeProvider; _signatureProvider = signatureProvider; _bitmexApiSocketProxy = bitmexApiSocketProxy; _actions = new Dictionary <string, IList <BitmexApiSubscriptionInfo> >(); _bitmexApiSocketProxy.DataReceived += BitmexApiSocketProxyDataReceived; }
public Wallet(ISignatureProvider signatureProvider, IHashFactory hashFactory) { HashFactory = hashFactory; Signer = signatureProvider; PublicKey = Signer.PublicKey; NumberOfTokens = 0; }
internal void SignMessage(ISignatureProvider signatureProvider) { if (signatureProvider.ShouldSignMessage(Domain, Identity)) { AssertDomainIsSet(); Signature = signatureProvider.CreateSignature(Domain, GetSignatureFields()); } }
/// <summary> /// Generates a Signature for a given package for tests. /// </summary> /// <param name="signatureProvider">Signature proivider to create the signature.</param> /// <param name="package">Package to be used for the signature.</param> /// <param name="request">SignPackageRequest containing the metadata for the signature request.</param> /// <param name="testLogger">ILogger.</param> /// <returns>Signature for the package.</returns> public static async Task <Signature> CreateSignatureForPackageAsync(ISignatureProvider signatureProvider, PackageArchiveReader package, SignPackageRequest request, TestLogger testLogger) { var zipArchiveHash = await package.GetArchiveHashAsync(request.SignatureHashAlgorithm, CancellationToken.None); var base64ZipArchiveHash = Convert.ToBase64String(zipArchiveHash); var signatureContent = new SignatureContent(SigningSpecifications.V1, request.SignatureHashAlgorithm, base64ZipArchiveHash); return(await signatureProvider.CreateSignatureAsync(request, signatureContent, testLogger, CancellationToken.None)); }
public ModuleTokenProvider(ISignatureProvider signatureProvider, string iotHubHostName, string deviceId, string moduleId, TimeSpan defaultTtl) { this.signatureProvider = signatureProvider ?? throw new ArgumentNullException(nameof(signatureProvider)); this.iotHubHostName = iotHubHostName; this.deviceId = deviceId; this.moduleId = moduleId; this.defaultTtl = defaultTtl; }
public JwtHelper(IJwtHelperConfiguration jwtHelperConfiguration, ISignatureProvider signatureProvider) { if (jwtHelperConfiguration == null || signatureProvider == null) { throw new ArgumentNullException("Arguments can not be null"); } _jwtHelperConfiguration = jwtHelperConfiguration; _signatureProvider = signatureProvider; }
public JwsBuilder(ISignatureProvider signatureProvider = null) { JsonSettings = new JsonSerializerSettings { NullValueHandling = NullValueHandling.Ignore, ContractResolver = new CamelCasePropertyNamesContractResolver(), DateFormatHandling = DateFormatHandling.IsoDateFormat }; this.signatureProvider = signatureProvider ?? new RsaSignatureProvider(); }
internal ModuleAuthenticationWithHsm( ISignatureProvider signatureProvider, string deviceId, string moduleId, string generationId, TimeSpan sasTokenTimeToLive, int sasTokenRenewalBuffer) : base(deviceId, moduleId, (int)sasTokenTimeToLive.TotalSeconds, sasTokenRenewalBuffer) { _signatureProvider = signatureProvider ?? throw new ArgumentNullException(nameof(signatureProvider)); _generationId = generationId ?? throw new ArgumentNullException(nameof(generationId)); }
internal void VerifySignature(ISignatureProvider signatureProvider) { if (signatureProvider.ShouldSignMessage(Domain, Identity)) { var mac = signatureProvider.CreateSignature(Domain, GetSignatureFields()); if (!Unsafe.ArraysEqual(Signature, mac)) { throw new WrongMessageSignatureException(); } } }
/// <summary> /// Returns a System.Net.Http.Headers.AuthenticationHeaderValue that represents the current RSA token exchange in JSON web token format. /// </summary> /// <param name="sign">The signature provider.</param> /// <param name="converter">A converter for payload.</param> /// <param name="serializer">An optional JSON serializer.</param> /// <param name="thisSide"> /// true if get the JSON web token payload without encryption for this side usage; /// otherwise, false, as default value, for the other side to send. /// </param> /// <returns>A System.Net.Http.Headers.AuthenticationHeaderValue that represents the current RSA token exchange in JSON web token format.</returns> public AuthenticationHeaderValue ToJsonWebTokenAuthenticationHeaderValue(ISignatureProvider sign, Func <JsonWebTokenPayload, object> converter, Func <object, string> serializer, bool thisSide = false) { var m = ToJsonWebTokenPayload(thisSide); var obj = converter != null?converter(m) : m; var jwt = new JsonWebToken <object>(obj, sign) { Serializer = serializer }; return(jwt.ToAuthenticationHeaderValue()); }
/// <summary> /// Converts to JSON web token. /// </summary> /// <param name="verifyAlgorithm">The signature algorithm instance to verify.</param> /// <param name="verify">true if need verify before converting; otherwise, false.</param> /// <param name="newSignatureAlgorithm">The new signature algorithm instance to use.</param> /// <returns>A JSON web token instance.</returns> public JsonWebToken <T> ToToken(ISignatureProvider verifyAlgorithm, bool verify, ISignatureProvider newSignatureAlgorithm) { if (verify && !Verify(verifyAlgorithm)) { return(null); } if (string.IsNullOrWhiteSpace(PayloadBase64Url)) { return(null); } return(new JsonWebToken <T>(GetPayload(), newSignatureAlgorithm)); }
/// <summary>Instantiates a new <see cref="SigningOptions" /> object.</summary> /// <param name="inputPackageStream">A readable stream for the package that will be used as input for any /// signing operation.</param> /// <param name="outputPackageStream">A readable and writeable stream for the output package for any signing /// operation.</param> /// <param name="overwrite">A flag indicating if an existing signature should be overwritten.</param> /// <param name="signatureProvider">A provider to create a Signature that can be added to the package.</param> /// <param name="logger">A logger.</param> /// <remarks>Signing operations cannot be done in place; therefore, <paramref name="inputPackageStream"/> /// and <paramref name="outputPackageStream" /> should be different streams.</remarks> /// <exception cref="ArgumentNullException">Thrown if <paramref name="inputPackageStream" /> is <c>null</c>.</exception> /// <exception cref="ArgumentNullException">Thrown if <paramref name="outputPackageStream" /> is <c>null</c>.</exception> /// <exception cref="ArgumentNullException">Thrown if <paramref name="signatureProvider" /> is <c>null</c>.</exception> /// <exception cref="ArgumentNullException">Thrown if <paramref name="logger" /> is <c>null</c>.</exception> /// <exception cref="ArgumentException">Thrown if <paramref name="inputPackageStream" /> and /// <paramref name="outputPackageStream"/> are the same object.</exception> public SigningOptions( Lazy <Stream> inputPackageStream, Lazy <Stream> outputPackageStream, bool overwrite, ISignatureProvider signatureProvider, ILogger logger) { _inputPackageStream = inputPackageStream ?? throw new ArgumentNullException(nameof(inputPackageStream)); _outputPackageStream = outputPackageStream ?? throw new ArgumentNullException(nameof(outputPackageStream)); SignatureProvider = signatureProvider ?? throw new ArgumentNullException(nameof(signatureProvider)); Logger = logger ?? throw new ArgumentNullException(nameof(logger)); Overwrite = overwrite; }
/// <summary> /// Creates xml representation of directory request /// </summary> public override string ToXml(ISignatureProvider signatureProvider) { var directoryRequestXmlMessage = new XDocument( new XDeclaration("1.0", "UTF-8", null), new XElement(Xml.Ns + "DirectoryReq", new XAttribute("version", "3.3.1"), new XElement(Xml.Ns + "createDateTimestamp", CreateDateTimestamp), new XElement(Xml.Ns + "Merchant", new XElement(Xml.Ns + "merchantID", MerchantId.PadLeft(9, '0')), new XElement(Xml.Ns + "subID", "0")))); return signatureProvider.SignRequestXml(directoryRequestXmlMessage); }
public BitmexApiSocketService(IBitmexAuthorization bitmexAuthorization, IExpiresTimeProvider expiresTimeProvider, ISignatureProvider signatureProvider, IBitmexApiSocketProxy bitmexApiSocketProxy, ILogger <BitmexApiSocketService>?logger = null) { _bitmexAuthorization = bitmexAuthorization; _expiresTimeProvider = expiresTimeProvider; _signatureProvider = signatureProvider; _bitmexApiSocketProxy = bitmexApiSocketProxy; _logger = logger ?? NullLogger <BitmexApiSocketService> .Instance; _bitmexApiSocketProxy.MessageReceived += MessageReceived; }
public ClientTokenProvider( ISignatureProvider signatureProvider, string iotHubHostName, string deviceId, string moduleId, TimeSpan defaultTtl) { this.signatureProvider = signatureProvider ?? throw new ArgumentNullException(nameof(signatureProvider)); this.iotHubHostName = iotHubHostName; this.deviceId = deviceId; this.moduleId = Option.Maybe(moduleId); this.defaultTtl = defaultTtl; this.tokenCache = new TokenCache(defaultTtl / 2); }
/// <summary> /// Creates xml representation of directory request /// </summary> public override string ToXml(ISignatureProvider signatureProvider) { XNamespace xmlNamespace = "http://www.idealdesk.com/ideal/messages/mer-acq/3.3.1"; var directoryRequestXmlMessage = new XDocument( new XDeclaration("1.0", "UTF-8", null), new XElement(xmlNamespace + "DirectoryReq", new XAttribute("version", "3.3.1"), new XElement(xmlNamespace + "createDateTimestamp", createDateTimestamp), new XElement(xmlNamespace + "Merchant", new XElement(xmlNamespace + "merchantID", MerchantId.PadLeft(9, '0')), new XElement(xmlNamespace + "subID", "0") ) ) ); return signatureProvider.SignXml(directoryRequestXmlMessage); }
public iDealResponse SendRequest(iDealRequest idealRequest, ISignatureProvider signatureProvider, string url, IiDealHttpResponseHandler iDealHttpResponseHandler) { // Create request var request = (HttpWebRequest)WebRequest.Create(url); request.ProtocolVersion = HttpVersion.Version11; request.ContentType = "text/xml"; request.Method = "POST"; // Set content var postBytes = Encoding.ASCII.GetBytes(idealRequest.ToXml(signatureProvider)); // Send var requestStream = request.GetRequestStream(); requestStream.Write(postBytes, 0, postBytes.Length); requestStream.Close(); // Return result var response = (HttpWebResponse)request.GetResponse(); return iDealHttpResponseHandler.HandleResponse(new StreamReader(response.GetResponseStream()).ReadToEnd(), signatureProvider); }
public iDealService(IConfiguration configuration, ISignatureProvider signatureProvider, IiDealHttpRequest iDealHttpRequest, IiDealHttpResponseHandler iDealHttpResponseHandler) { // Configuration guard clauses if (string.IsNullOrWhiteSpace(configuration.MerchantId)) { throw new ConfigurationErrorsException("Merchant Id is not set"); } if (configuration.MerchantId.Length > 9) { throw new ConfigurationErrorsException("Merchant Id cannot contain more as 9 characters"); } if (configuration.MerchantSubId < 0 || configuration.MerchantSubId > 6) { throw new ConfigurationErrorsException("SubId must contain a value ranging from 0 to 6"); } if (string.IsNullOrWhiteSpace(configuration.AcquirerUrl)) { throw new ConfigurationErrorsException("Url of acquirer is not set"); } if (configuration.AcceptantCertificate == null) { throw new ConfigurationErrorsException("Acceptant's certificate is not set"); } if (!configuration.AcceptantCertificate.HasPrivateKey) { throw new ConfigurationErrorsException("Acceptant's certificate does not contain private key"); } if (configuration.AcquirerCertificate == null) { throw new ConfigurationErrorsException("Acquirer's certificate is not set"); } this.configuration = configuration; this.signatureProvider = signatureProvider; this.iDealHttpRequest = iDealHttpRequest; this.iDealHttpResponseHandler = iDealHttpResponseHandler; }
private async Task TestOAuth10(IHttpClientFactory httpClientFactory, ISignatureProvider signatureProvider) { var client = new RestClient("http://oauthbin.com/v1/") { HttpClientFactory = httpClientFactory, }; var consumerKey = "key"; var consumerSecret = "secret"; var authenticator = OAuth1Authenticator.ForRequestToken(consumerKey, consumerSecret, "http://localhost/test"); authenticator.SignatureProvider = signatureProvider; client.Authenticator = authenticator; string requestToken, requestTokenSecret; { var request = new RestRequest("request-token"); var response = await client.Execute(request); var requestTokenResponse = Encoding.UTF8.GetString(response.RawBytes); Assert.DoesNotContain('\n', requestTokenResponse); var tokenInfo = (from part in requestTokenResponse.Split('&') let equalSignPos = part.IndexOf('=') let partKey = part.Substring(0, equalSignPos) let partValue = part.Substring(equalSignPos + 1) select new { partKey, partValue }).ToDictionary(x => x.partKey, x => x.partValue); Assert.Contains("oauth_token", tokenInfo.Keys); Assert.Contains("oauth_token_secret", tokenInfo.Keys); requestToken = tokenInfo["oauth_token"]; requestTokenSecret = tokenInfo["oauth_token_secret"]; } authenticator = OAuth1Authenticator.ForAccessToken(consumerKey, consumerSecret, requestToken, requestTokenSecret); authenticator.SignatureProvider = signatureProvider; client.Authenticator = authenticator; string accessKey, accessSecret; { var request = new RestRequest("access-token"); var response = await client.Execute(request); var accessTokenResponse = Encoding.UTF8.GetString(response.RawBytes); Assert.DoesNotContain('\n', accessTokenResponse); var tokenInfo = (from part in accessTokenResponse.Split('&') let equalSignPos = part.IndexOf('=') let partKey = part.Substring(0, equalSignPos) let partValue = part.Substring(equalSignPos + 1) select new { partKey, partValue }).ToDictionary(x => x.partKey, x => x.partValue); Assert.Contains("oauth_token", tokenInfo.Keys); Assert.Contains("oauth_token_secret", tokenInfo.Keys); accessKey = tokenInfo["oauth_token"]; accessSecret = tokenInfo["oauth_token_secret"]; } authenticator = OAuth1Authenticator.ForProtectedResource(consumerKey, consumerSecret, accessKey, accessSecret); authenticator.SignatureProvider = signatureProvider; client.Authenticator = authenticator; { var request = new RestRequest("echo", Method.POST); request.AddParameter("one", "1"); request.AddParameter("two", "2"); var response = await client.Execute(request); var text = Encoding.UTF8.GetString(response.RawBytes); Assert.DoesNotContain('\n', text); var data = (from part in text.Split('&') let equalSignPos = part.IndexOf('=') let partKey = part.Substring(0, equalSignPos) let partValue = part.Substring(equalSignPos + 1) select new { partKey, partValue }).ToDictionary(x => x.partKey, x => x.partValue); Assert.Contains("one", data.Keys); Assert.Contains("two", data.Keys); Assert.Equal("1", data["one"]); Assert.Equal("2", data["two"]); } }
/// <summary> /// Verify the signature against the unsigned data. The encryptedData is decrypted using the public key and /// the unsignedData is hashed and compared to the un-encrypted signed data using the supplied SignatureProvider. /// </summary> /// <param name="unsignedData">The raw, unencrypted data to be hashed and compared.</param> /// <param name="encryptedData">The data that has been hashed and encrypted with the private key.</param> /// <param name="signatureProvider">The signature provider that matches the algorithm used to generate the original signature</param> /// <returns>Boolean representing whether the signature was valid (verified)</returns> public bool VerifyData(byte[] unsignedData, byte[] encryptedData, ISignatureProvider signatureProvider) { if (m_isBusy == true) throw new CryptographicException("Operation cannot be performed while a current key generation operation is in progress."); if (m_KeyLoaded == false) throw new CryptographicException("No key has been loaded. You must import a key or make a call to GenerateKeys() before performing data operations."); return signatureProvider.VerifySignature(unsignedData, DoDecryptPublic(ref encryptedData), m_RSAParams); }
/// <summary> /// Sign a hash of the input data using the supplied Signature Provider and encrypt with the private key. /// </summary> /// <param name="dataBytes">Data to be hashed and signed</param> /// <param name="signatureProvider">The signature provider to use for signature generation.</param> /// <returns>Signed hash bytes</returns> public byte[] SignData(byte[] dataBytes, ISignatureProvider signatureProvider) { if (m_isBusy == true) throw new CryptographicException("Operation cannot be performed while a current key generation operation is in progress."); if (m_KeyLoaded == false) throw new CryptographicException("No key has been loaded. You must import a key or make a call to GenerateKeys() before performing data operations."); //Key validation is done in the DoEncryptPrivate method. return DoEncryptPrivate(signatureProvider.EncodeSignature(dataBytes, m_RSAParams)); }
public override string ToXml(ISignatureProvider signatureProvider) { XNamespace xmlNamespace = "http://www.idealdesk.com/ideal/messages/mer-acq/3.3.1"; var directoryRequestXmlMessage = new XDocument( new XDeclaration("1.0", "UTF-8", null), new XElement(xmlNamespace + "AcquirerTrxReq", new XAttribute("version", "3.3.1"), new XElement(xmlNamespace + "createDateTimestamp", createDateTimestamp), new XElement(xmlNamespace + "Issuer", new XElement(xmlNamespace + "issuerID", IssuerId.ToString().PadLeft(4,'0')) ), new XElement(xmlNamespace + "Merchant", new XElement(xmlNamespace + "merchantID", MerchantId.PadLeft(9, '0')), new XElement(xmlNamespace + "subID", "0"), new XElement(xmlNamespace + "merchantReturnURL", MerchantReturnUrl) ), new XElement(xmlNamespace + "Transaction", new XElement(xmlNamespace + "purchaseID", PurchaseId), new XElement(xmlNamespace + "amount", Amount), new XElement(xmlNamespace + "currency", "EUR"), new XElement(xmlNamespace + "expirationPeriod", "PT" + Convert.ToInt32(Math.Floor(ExpirationPeriod.Value.TotalSeconds)) + "S"), new XElement(xmlNamespace + "language", "nl"), new XElement(xmlNamespace + "description", Description), new XElement(xmlNamespace + "entranceCode", EntranceCode) ) ) ); return signatureProvider.SignXml(directoryRequestXmlMessage); }
///<summary> /// Signature module filter requires container with trusted signatures to check module signature against. ///</summary> ///<param name="signatureProvider">container with trusted signatures</param> public SignatureModuleFilter(ISignatureProvider signatureProvider) { _signatureProvider = signatureProvider; }
/// <summary> /// Creates a signature value given a signature base and the consumer secret and a known token secret. /// </summary> /// <a href="http://oauth.net/core/1.0#rfc.section.9.2"/> /// <param name="signatureProvider">The hashing method</param> /// <param name="signatureTreatment">The treatment to use on a signature value</param> /// <param name="signatureBase">The signature base</param> /// <param name="consumerSecret">The consumer secret</param> /// <param name="tokenSecret">The token secret</param> /// <returns></returns> public static string GetSignature( ISignatureProvider signatureProvider, OAuthSignatureTreatment signatureTreatment, string signatureBase, string consumerSecret, string tokenSecret) { if (string.IsNullOrEmpty(tokenSecret)) { tokenSecret = string.Empty; } consumerSecret = UrlEncodeRelaxed(consumerSecret); tokenSecret = UrlEncodeRelaxed(tokenSecret); var data = _encoding.GetBytes(signatureBase); var hash = signatureProvider.CalculateSignature(data, consumerSecret, tokenSecret); var signature = hash; var result = signatureTreatment == OAuthSignatureTreatment.Escaped ? UrlEncodeRelaxed(signature) : signature; return result; }
/// <summary> /// Creates a signature value given a signature base and the consumer secret and a known token secret. /// </summary> /// <a href="http://oauth.net/core/1.0#rfc.section.9.2"/> /// <param name="signatureProvider">The hashing method</param> /// <param name="signatureBase">The signature base</param> /// <param name="consumerSecret">The consumer secret</param> /// <param name="tokenSecret">The token secret</param> /// <returns></returns> public static string GetSignature(ISignatureProvider signatureProvider, string signatureBase, string consumerSecret, string tokenSecret) { return GetSignature(signatureProvider, OAuthSignatureTreatment.Escaped, signatureBase, consumerSecret, tokenSecret); }
/// <summary> /// Creates a signature value given a signature base and the consumer secret. /// This method is used when the token secret is currently unknown. /// </summary> /// <a href="http://oauth.net/core/1.0#rfc.section.9.2"/> /// <param name="signatureProvider">The hashing method</param> /// <param name="signatureTreatment">The treatment to use on a signature value</param> /// <param name="signatureBase">The signature base</param> /// <param name="consumerSecret">The consumer key</param> /// <returns></returns> public static string GetSignature(ISignatureProvider signatureProvider, OAuthSignatureTreatment signatureTreatment, string signatureBase, string consumerSecret) { return GetSignature(signatureProvider, signatureTreatment, signatureBase, consumerSecret, null); }
public OtpGenerator(IPasswordGenerator passwordGenerator, ISignatureProvider signatureProvider) { _passwordGenerator = passwordGenerator; _signatureProvider = signatureProvider; }
public abstract string ToXml(ISignatureProvider signatureProvider);
public override string ToXml(ISignatureProvider signatureProvider) { var directoryRequestXmlMessage = new XDocument( new XDeclaration("1.0", "UTF-8", null), new XElement(Xml.Ns + "AcquirerTrxReq", new XAttribute("version", "3.3.1"), new XElement(Xml.Ns + "createDateTimestamp", CreateDateTimestamp), new XElement(Xml.Ns + "Issuer", new XElement(Xml.Ns + "issuerID", IssuerId.PadLeft(4, '0'))), new XElement(Xml.Ns + "Merchant", new XElement(Xml.Ns + "merchantID", MerchantId.PadLeft(9, '0')), new XElement(Xml.Ns + "subID", "0"), new XElement(Xml.Ns + "merchantReturnURL", MerchantReturnUrl)), new XElement(Xml.Ns + "Transaction", new XElement(Xml.Ns + "purchaseID", PurchaseId), new XElement(Xml.Ns + "amount", Amount.ToString("0.##", CultureInfo.InvariantCulture)), new XElement(Xml.Ns + "currency", "EUR"), new XElement(Xml.Ns + "expirationPeriod", "PT" + Convert.ToInt32(Math.Floor(ExpirationPeriod.Value.TotalSeconds)) + "S"), new XElement(Xml.Ns + "language", "nl"), new XElement(Xml.Ns + "description", Description), new XElement(Xml.Ns + "entranceCode", EntranceCode)))); return signatureProvider.SignRequestXml(directoryRequestXmlMessage); }
public void setup() { _signatureProvider = new SignatureProvider(); }