public OffchainTransactionBuilderService(
ITransactionBuildHelper transactionBuildHelper,
RpcConnectionParams connectionParams,
IMultisigService multisigService,
IBitcoinOutputsService bitcoinOutputsService,
IOffchainChannelRepository offchainChannelRepository,
ISignatureVerifier signatureVerifier,
Func <SignatureApiProviderType, ISignatureApiProvider> signatureApiProviderFactory,
ICommitmentRepository commitmentRepository,
IPregeneratedOutputsQueueFactory pregeneratedOutputsQueueFactory,
IBroadcastedOutputRepository broadcastedOutputRepository,
ILykkeTransactionBuilderService lykkeTransactionBuilderService,
IRpcBitcoinClient rpcBitcoinClient)
{
_transactionBuildHelper = transactionBuildHelper;
_connectionParams = connectionParams;
_multisigService = multisigService;
_bitcoinOutputsService = bitcoinOutputsService;
_offchainChannelRepository = offchainChannelRepository;
_signatureVerifier = signatureVerifier;
_signatureApiProvider = signatureApiProviderFactory(SignatureApiProviderType.Exchange);
_commitmentRepository = commitmentRepository;
_pregeneratedOutputsQueueFactory = pregeneratedOutputsQueueFactory;
_broadcastedOutputRepository = broadcastedOutputRepository;
_lykkeTransactionBuilderService = lykkeTransactionBuilderService;
_rpcBitcoinClient = rpcBitcoinClient;
}
public APIServer(IGroupRepository groupRepository, IEmailSender emailSender, ISimpleRandomGenerator simpleRandomGenerator, ISignatureVerifier signatureVerifier)
{
this.groupRepository = groupRepository;
this.emailSender = emailSender;
this.simpleRandomGenerator = simpleRandomGenerator;
this.signatureVerifier = signatureVerifier;
}
protected virtual void CheckSignature(
ISignatureVerifier verifier)
{
if (!cert.SignatureAlgorithm.Equals(cert.ACInfo.Signature))
{
throw new CertificateException("Signature algorithm in certificate info not same as outer certificate");
}
IStreamCalculator streamCalculator = verifier.CreateCalculator();
try
{
byte[] b = this.cert.ACInfo.GetEncoded();
streamCalculator.Stream.Write(b, 0, b.Length);
streamCalculator.Stream.Close();
}
catch (IOException e)
{
throw new SignatureException("Exception encoding certificate info object", e);
}
if (!((IVerifier)streamCalculator.GetResult()).IsVerified(this.GetSignature()))
{
throw new InvalidKeyException("Public key presented not for certificate signature");
}
}
/// <summary>
/// Setup the app cast handler info for downloading and parsing app cast information
/// </summary>
/// <param name="dataDownloader">downloader that will manage the app cast download
/// (provided by <see cref="SparkleUpdater"/> via the
/// <see cref="SparkleUpdater.AppCastDataDownloader"/> property.</param>
/// <param name="castUrl">full URL to the app cast file</param>
/// <param name="config">configuration for handling update intervals/checks
/// (user skipped versions, etc.)</param>
/// <param name="signatureVerifier">Object to check signatures of app cast information</param>
/// <param name="logWriter">object that you can utilize to do any necessary logging</param>
public void SetupAppCastHandler(IAppCastDataDownloader dataDownloader, string castUrl, Configuration config, ISignatureVerifier signatureVerifier, ILogger logWriter = null)
{
_dataDownloader = dataDownloader;
_config = config;
_castUrl = castUrl;
_signatureVerifier = signatureVerifier;
_logWriter = logWriter ?? new LogWriter();
}
///
public HomeController(
ILogger <HomeController> logger,
ISignatureVerifier signatureVerifier,
IMessageSink sink)
{
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_signatureVerifier = signatureVerifier ?? throw new ArgumentNullException(nameof(signatureVerifier));
_sink = sink;
}
public RequestSignatureVerificationOrchestrator(
IClientStore clientStore,
ISignatureVerifier signatureVerifier,
IVerificationResultCreatorFactory verificationResultCreatorFactory,
ILogger <RequestSignatureVerificationOrchestrator> logger = null)
{
_clientStore = clientStore ?? throw new ArgumentNullException(nameof(clientStore));
_signatureVerifier = signatureVerifier ?? throw new ArgumentNullException(nameof(signatureVerifier));
_verificationResultCreatorFactory = verificationResultCreatorFactory ?? throw new ArgumentNullException(nameof(verificationResultCreatorFactory));
_logger = logger;
}
public RequestAuthenticator(
ILogger <RequestAuthenticator> logger,
ISignatureVerifier signatureVerifier,
IOptionsMonitor <EventListenerOptions> optionsMonitor)
{
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_signatureVerifier = signatureVerifier
?? throw new ArgumentNullException(nameof(signatureVerifier));
_optionsMonitorMonitor = optionsMonitor
?? throw new ArgumentNullException(nameof(optionsMonitor));
}
public WebhookServices(ISignatureVerifier signatureVerifier
, PayloadTable storeTable, ITokenStore tokenStore, TenantAccess tenantAccess
, AccountingApi accountingApi)
{
//_client = httpClient;
_signatureVerifier = signatureVerifier;
_storeTable = storeTable;
_tokenStore = tokenStore;
_accountingApi = accountingApi;
_tenantAccess = tenantAccess;
}
public WebhooksController(IQueue <string> payloadQueue,
ISignatureVerifier signatureVerifier,
ILogger <WebhooksController> logger,
IEmployeeService employeeService,
ILiveDataService service)
{
_signatureVerifier = signatureVerifier;
_logger = logger;
_employeeService = employeeService;
_contactObservable = service.RecentActivity as ContactObservable;
}
public CommandController(
AppSettings settings,
ISigner signer,
ISignatureVerifier verifier,
ICertificateProcessor certificateProcessor,
ICertificateSerializer certificateSerializer)
{
_settings = settings;
_signer = signer;
_verifier = verifier;
_certificateProcessor = certificateProcessor;
_certificateSerializer = certificateSerializer;
}
public bool Verify(
ISignatureVerifier verifier)
{
try
{
byte[] b = reqInfo.GetDerEncoded();
IStreamCalculator streamCalculator = verifier.CreateCalculator();
streamCalculator.Stream.Write(b, 0, b.Length);
streamCalculator.Stream.Close();
return(((IVerifier)streamCalculator.GetResult()).IsVerified(sigBits.GetBytes()));
}
catch (Exception e)
{
throw new SignatureException("exception encoding TBS cert request", e);
}
}
protected virtual void CheckSignature(
ISignatureVerifier verifier)
{
if (!c.SignatureAlgorithm.Equals(c.TbsCertList.Signature))
{
throw new CrlException("Signature algorithm on CertificateList does not match TbsCertList.");
}
Asn1Encodable parameters = c.SignatureAlgorithm.Parameters;
IStreamCalculator streamCalculator = verifier.CreateCalculator();
byte[] b = this.GetTbsCertList();
streamCalculator.Stream.Write(b, 0, b.Length);
streamCalculator.Stream.Close();
if (!((IVerifier)streamCalculator.GetResult()).IsVerified(this.GetSignature()))
{
throw new InvalidKeyException("CRL does not verify with supplied public key.");
}
}
protected virtual void CheckSignature(
ISignatureVerifier verifier)
{
if (!IsAlgIDEqual(c.SignatureAlgorithm, c.TbsCertificate.Signature))
{
throw new CertificateException("signature algorithm in TBS cert not same as outer cert");
}
Asn1Encodable parameters = c.SignatureAlgorithm.Parameters;
IStreamCalculator streamCalculator = verifier.CreateCalculator();
byte[] b = this.GetTbsCertificate();
streamCalculator.Stream.Write(b, 0, b.Length);
streamCalculator.Stream.Close();
if (!((IVerifier)streamCalculator.GetResult()).IsVerified(this.GetSignature()))
{
throw new InvalidKeyException("Public key presented not for certificate signature");
}
}
protected virtual void CheckSignature(
ISignatureVerifier verifier)
{
if (!cert.SignatureAlgorithm.Equals(cert.ACInfo.Signature))
{
throw new CertificateException("Signature algorithm in certificate info not same as outer certificate");
}
IStreamCalculator streamCalculator = verifier.CreateCalculator();
try
{
byte[] b = this.cert.ACInfo.GetEncoded();
streamCalculator.Stream.Write(b, 0, b.Length);
streamCalculator.Stream.Close();
}
catch (IOException e)
{
throw new SignatureException("Exception encoding certificate info object", e);
}
if (!((IVerifier)streamCalculator.GetResult()).IsVerified(this.GetSignature()))
{
throw new InvalidKeyException("Public key presented not for certificate signature");
}
}
protected virtual void CheckSignature(
ISignatureVerifier verifier)
{
if (!IsAlgIDEqual(c.SignatureAlgorithm, c.TbsCertificate.Signature))
throw new CertificateException("signature algorithm in TBS cert not same as outer cert");
Asn1Encodable parameters = c.SignatureAlgorithm.Parameters;
IStreamCalculator streamCalculator = verifier.CreateCalculator();
byte[] b = this.GetTbsCertificate();
streamCalculator.Stream.Write(b, 0, b.Length);
streamCalculator.Stream.Close();
if (!((IVerifier)streamCalculator.GetResult()).IsVerified(this.GetSignature()))
{
throw new InvalidKeyException("Public key presented not for certificate signature");
}
}
public bool VerifyBlockSignature(ISignatureVerifier verifier) => verifier.VerifyHash(MinerAddress, Hash, MinerSignature);
public EndPointController(ISignatureVerifier signatureVerifier, IAPIService apiService)
{
_signatureVerifier = signatureVerifier ?? throw new ArgumentNullException(nameof(signatureVerifier));
_apiService = apiService ?? throw new ArgumentNullException(nameof(apiService));
}
/// <summary>
/// ctor which needs the appcast url and a referenceassembly
/// </summary>
/// <param name="appcastUrl">the URL of the appcast file</param>
/// <param name="signatureVerifier">the object that will verify your appcast signatures.</param>
/// <param name="referenceAssembly">the name of the assembly to use for comparison when checking update versions</param>
public SelfSparkleUpdater(string appcastUrl, ISignatureVerifier signatureVerifier, string referenceAssembly)
: this(appcastUrl, signatureVerifier, referenceAssembly, null)
{
}
public bool VerifyTransactionSignature(ISignatureVerifier verifier) => verifier.VerifyHash(Sender, Hash, Signature);
/// <summary>
/// ctor which needs the appcast url and a referenceassembly
/// </summary>
/// <param name="appcastUrl">the URL of the appcast file</param>
/// <param name="signatureVerifier">the object that will verify your appcast signatures.</param>
/// <param name="referenceAssembly">the name of the assembly to use for comparison when checking update versions</param>
/// <param name="factory">a UI factory to use in place of the default UI</param>
public SelfSparkleUpdater(string appcastUrl, ISignatureVerifier signatureVerifier, string referenceAssembly, IUIFactory factory)
: base(appcastUrl, signatureVerifier, referenceAssembly, factory)
{
}
protected virtual void CheckSignature(
ISignatureVerifier verifier)
{
if (!c.SignatureAlgorithm.Equals(c.TbsCertList.Signature))
{
throw new CrlException("Signature algorithm on CertificateList does not match TbsCertList.");
}
Asn1Encodable parameters = c.SignatureAlgorithm.Parameters;
IStreamCalculator streamCalculator = verifier.CreateCalculator();
byte[] b = this.GetTbsCertList();
streamCalculator.Stream.Write(b, 0, b.Length);
streamCalculator.Stream.Close();
if (!((IVerifier)streamCalculator.GetResult()).IsVerified(this.GetSignature()))
{
throw new InvalidKeyException("CRL does not verify with supplied public key.");
}
}
public bool Verify(
ISignatureVerifier verifier)
{
try
{
byte[] b = reqInfo.GetDerEncoded();
IStreamCalculator streamCalculator = verifier.CreateCalculator();
streamCalculator.Stream.Write(b, 0, b.Length);
streamCalculator.Stream.Close();
return ((IVerifier)streamCalculator.GetResult()).IsVerified(sigBits.GetBytes());
}
catch (Exception e)
{
throw new SignatureException("exception encoding TBS cert request", e);
}
}
/// <summary>
/// Assert that all the <see cref="IdTokenRequirements"/> are met by a JWT ID token for a given point in time.
/// </summary>
/// <param name="required"><see cref="IdTokenRequirements"/> that should be asserted.</param>
/// <param name="rawIDToken">Raw ID token to assert requirements against.</param>
/// <param name="pointInTime">Optional <see cref="DateTime"/> to act as "Now" in order to facilitate unit testing with static tokens.</param>
/// <param name="signatureVerifier">Optional <see cref="ISignatureVerifier"/> to perform signature verification and token extraction. If unspecified
/// <see cref="AsymmetricSignatureVerifier"/> is used against the <paramref name="required"/> Issuer.</param>
/// <exception cref="IdTokenValidationException">Exception thrown if <paramref name="rawIDToken"/> fails to
/// meet the requirements specified by <paramref name="required"/>.
/// </exception>
/// <returns><see cref="Task"/> that will complete when the token is validated.</returns>
internal static async Task AssertTokenMeetsRequirements(this IdTokenRequirements required, string rawIDToken, DateTime?pointInTime = null, ISignatureVerifier signatureVerifier = null)
{
if (string.IsNullOrWhiteSpace(rawIDToken))
{
throw new IdTokenValidationException("ID token is required but missing.");
}
var token = DecodeToken(rawIDToken);
// For now we want to support HS256 + ClientSecret as we just had a major release.
// TODO: In the next major (v4.0) we should remove this condition as well as Auth0ClientOptions.ClientSecret
if (token.SignatureAlgorithm != "HS256")
{
(signatureVerifier ?? await AsymmetricSignatureVerifier.ForJwks(required.Issuer)).VerifySignature(rawIDToken);
}
AssertTokenClaimsMeetRequirements(required, token, pointInTime ?? DateTime.Now);
}
private Task ValidateToken(string token, IdTokenRequirements reqs = null, DateTime?when = null, ISignatureVerifier signatureVerifier = null)
{
return(IdTokenValidator.AssertTokenMeetsRequirements(reqs ?? defaultReqs, token, when ?? tokensWereValid, signatureVerifier ?? rs256NoSignature));
}
/// <summary>
/// Initializes a new instance of the <see cref="InstalledLicenseContainer"/> class.
/// </summary>
/// <param name="store">The store.</param>
/// <param name="verifier">The verifier.</param>
/// <param name="log">The log.</param>
public InstalledLicenseContainer(ILicenseStore store, ISignatureVerifier verifier, ILog log)
{
_store = store;
_verifier = verifier;
_log = log;
}
public WebhooksController(IQueue <string> payloadQueue, ISignatureVerifier signatureVerifier, ILogger <WebhooksController> logger)
{
_payloadQueue = payloadQueue;
_signatureVerifier = signatureVerifier;
_logger = logger;
}
/// <summary>
/// Setups the application cast handler.
/// </summary>
/// <param name="dataDownloader">The data downloader.</param>
/// <param name="castUrl">The cast URL.</param>
/// <param name="config">The configuration.</param>
/// <param name="signatureVerifier">The signature verifier.</param>
/// <param name="logWriter">The log writer.</param>
public void SetupAppCastHandler(IAppCastDataDownloader dataDownloader, string castUrl, Configuration config, ISignatureVerifier signatureVerifier, ILogger logWriter = null)
{
this.config = config;
this.signatureVerifier = signatureVerifier;
appCast.SetupAppCastHandler(dataDownloader, castUrl, config, signatureVerifier, logWriter);
}
