Ejemplo n.º 1
0
        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);
            }
        }
Ejemplo n.º 2
0
 /// <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");
            }
        }
Ejemplo n.º 4
0
        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));
        }
Ejemplo n.º 5
0
        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");
            }
        }
Ejemplo n.º 6
0
        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));
        }
Ejemplo n.º 7
0
        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);
                }
            }
        }
Ejemplo n.º 8
0
        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));
        }
Ejemplo n.º 9
0
            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));
            }
Ejemplo n.º 10
0
        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");
            }
        }
Ejemplo n.º 11
0
        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);
        }
Ejemplo n.º 12
0
        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);
        }
Ejemplo n.º 13
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));
        }
Ejemplo n.º 14
0
            /// <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);
            }
Ejemplo n.º 15
0
 public TransactionBuilder(GXRPC rpc, ISignatureProvider provider, string chainId)
 {
     this.RPC = rpc;
     this.signatureProvider = provider;
     this.operations        = new List <Operation>();
     this.ChainId           = chainId;
 }
Ejemplo n.º 16
0
 public ClientTokenProvider(
     ISignatureProvider signatureProvider,
     string iotHubHostName,
     string deviceId,
     TimeSpan defaultTtl)
     : this(signatureProvider, iotHubHostName, deviceId, null, defaultTtl)
 {
 }
Ejemplo n.º 17
0
 public KrakenClient(
     IOptions <KrakenClientOptions> options,
     ISignatureProvider signatureProvider)
     : base(options)
 {
     _options           = options;
     _signatureProvider = signatureProvider;
 }
Ejemplo n.º 18
0
 /// <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);
 }
Ejemplo n.º 19
0
 /**
  * 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();
 }
Ejemplo n.º 20
0
 /// <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;
 }
Ejemplo n.º 21
0
 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;
 }
Ejemplo n.º 22
0
        public Wallet(ISignatureProvider signatureProvider, IHashFactory hashFactory)
        {
            HashFactory = hashFactory;

            Signer = signatureProvider;

            PublicKey      = Signer.PublicKey;
            NumberOfTokens = 0;
        }
Ejemplo n.º 23
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));
        }
Ejemplo n.º 25
0
 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;
 }
Ejemplo n.º 26
0
        public JwtHelper(IJwtHelperConfiguration jwtHelperConfiguration, ISignatureProvider signatureProvider)
        {
            if (jwtHelperConfiguration == null || signatureProvider == null)
            {
                throw new ArgumentNullException("Arguments can not be null");
            }

            _jwtHelperConfiguration = jwtHelperConfiguration;
            _signatureProvider      = signatureProvider;
        }
Ejemplo n.º 27
0
 public JwsBuilder(ISignatureProvider signatureProvider = null)
 {
     JsonSettings = new JsonSerializerSettings
     {
         NullValueHandling  = NullValueHandling.Ignore,
         ContractResolver   = new CamelCasePropertyNamesContractResolver(),
         DateFormatHandling = DateFormatHandling.IsoDateFormat
     };
     this.signatureProvider = signatureProvider ?? new RsaSignatureProvider();
 }
Ejemplo n.º 28
0
 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));
 }
Ejemplo n.º 29
0
        internal void VerifySignature(ISignatureProvider signatureProvider)
        {
            if (signatureProvider.ShouldSignMessage(Domain, Identity))
            {
                var mac = signatureProvider.CreateSignature(Domain, GetSignatureFields());

                if (!Unsafe.ArraysEqual(Signature, mac))
                {
                    throw new WrongMessageSignatureException();
                }
            }
        }
Ejemplo n.º 30
0
    /// <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());
    }
Ejemplo n.º 31
0
 /// <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));
 }
Ejemplo n.º 32
0
 /// <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;
 }
Ejemplo n.º 33
0
        /// <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);
        }
Ejemplo n.º 34
0
 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;
 }
Ejemplo n.º 35
0
 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);
 }
Ejemplo n.º 36
0
        /// <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);
        }
Ejemplo n.º 37
0
        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);
        }
Ejemplo n.º 38
0
        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"]);
            }
        }
Ejemplo n.º 40
0
        /// <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);
        }
Ejemplo n.º 41
0
        /// <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));
        }
Ejemplo n.º 42
0
        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);
        }
Ejemplo n.º 43
0
 ///<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;
 }
Ejemplo n.º 44
0
        /// <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;
        }
Ejemplo n.º 45
0
 /// <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);
 }
Ejemplo n.º 46
0
 /// <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);
 }
Ejemplo n.º 47
0
 public OtpGenerator(IPasswordGenerator passwordGenerator, ISignatureProvider signatureProvider)
 {
     _passwordGenerator = passwordGenerator;
     _signatureProvider = signatureProvider;
 }
Ejemplo n.º 48
0
 public abstract string ToXml(ISignatureProvider signatureProvider);
Ejemplo n.º 49
0
        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);
        }
Ejemplo n.º 50
0
 public void setup()
 {
     _signatureProvider = new SignatureProvider();
 }