public void Init() { var serverCredentials = new SslServerCredentials(new[] { new KeyCertificatePair(File.ReadAllText(TestCredentials.ServerCertChainPath), File.ReadAllText(TestCredentials.ServerPrivateKeyPath)) }); server = new Server { Services = { TestService.BindService(new TestServiceImpl()) }, Ports = { { Host, ServerPort.PickUnused, serverCredentials } } }; server.Start(); var options = new List<ChannelOption> { new ChannelOption(ChannelOptions.SslTargetNameOverride, TestCredentials.DefaultHostOverride) }; var asyncAuthInterceptor = new AsyncAuthInterceptor(async (authUri, metadata) => { await Task.Delay(100); // make sure the operation is asynchronous. metadata.Add("authorization", "SECRET_TOKEN"); }); var clientCredentials = ChannelCredentials.Create( new SslCredentials(File.ReadAllText(TestCredentials.ClientCertAuthorityPath)), new MetadataCredentials(asyncAuthInterceptor)); channel = new Channel(Host, server.Ports.Single().BoundPort, clientCredentials, options); client = TestService.NewClient(channel); }
static ChannelCredentials CreateCredentials(bool mutualTls, bool useJwt) { var certsPath = Environment.GetEnvironmentVariable("CERTS_PATH"); var caRoots = File.ReadAllText(Path.Combine(certsPath, "ca.pem")); ChannelCredentials channelCredentials; if (!mutualTls) { channelCredentials = new SslCredentials(caRoots); } else { var keyCertPair = new KeyCertificatePair( File.ReadAllText(Path.Combine(certsPath, "client.pem")), File.ReadAllText(Path.Combine(certsPath, "client.key"))); channelCredentials = new SslCredentials(caRoots, keyCertPair); } if (useJwt) { var authInterceptor = new AsyncAuthInterceptor(async(context, metadata) => { metadata.Add( new Metadata.Entry("authorization", "Bearer " + GenerateJwt())); }); var metadataCredentials = CallCredentials.FromInterceptor(authInterceptor); channelCredentials = ChannelCredentials.Create(channelCredentials, metadataCredentials); } return(channelCredentials); }
public async Task ConnectAsync(RobotConnectionInfo connectionInfo) { if (Client == null) { //create channel var ssl = new SslCredentials(connectionInfo.Certificate); var interceptor = new AsyncAuthInterceptor((context, metadata) => { metadata.Add("authorization", $"Bearer {connectionInfo.Token}"); return(Task.CompletedTask); }); var cred = ChannelCredentials.Create(ssl, CallCredentials.FromInterceptor(interceptor)); _channel = new Channel(connectionInfo.IpAddress, 443, cred, new ChannelOption[] { new ChannelOption("grpc.ssl_target_name_override", connectionInfo.RobotName) }); //connect to client try { await _channel.ConnectAsync(DateTime.UtcNow.AddSeconds(10)); } catch (TaskCanceledException ex) { throw new VectorConnectionException("could not connect to Vector. insure IP address is correct and that Vector is turned on", ex); } //create client Client = new ExternalInterfaceClient(_channel); IsConnected = true; } }
public void Init() { var serverCredentials = new SslServerCredentials(new[] { new KeyCertificatePair(File.ReadAllText(TestCredentials.ServerCertChainPath), File.ReadAllText(TestCredentials.ServerPrivateKeyPath)) }); server = new Server { Services = { TestService.BindService(new TestServiceImpl()) }, Ports = { { Host, ServerPort.PickUnused, serverCredentials } } }; server.Start(); var options = new List <ChannelOption> { new ChannelOption(ChannelOptions.SslTargetNameOverride, TestCredentials.DefaultHostOverride) }; var asyncAuthInterceptor = new AsyncAuthInterceptor(async(authUri, metadata) => { await Task.Delay(100); // make sure the operation is asynchronous. metadata.Add("authorization", "SECRET_TOKEN"); }); var clientCredentials = ChannelCredentials.Create( new SslCredentials(File.ReadAllText(TestCredentials.ClientCertAuthorityPath)), CallCredentials.FromInterceptor(asyncAuthInterceptor)); channel = new Channel(Host, server.Ports.Single().BoundPort, clientCredentials, options); client = TestService.NewClient(channel); }
public override void SetAsyncAuthInterceptorCredentials(object state, AsyncAuthInterceptor interceptor) { GrpcPreconditions.CheckState(nativeCredentials == null); var plugin = new NativeMetadataCredentialsPlugin(interceptor); nativeCredentials = plugin.Credentials; }
public NativeMetadataCredentialsPlugin(AsyncAuthInterceptor interceptor) { this.interceptor = Preconditions.CheckNotNull(interceptor, "interceptor"); this.nativeInterceptor = NativeMetadataInterceptorHandler; // Make sure the callback doesn't get garbage collected until it is destroyed. this.gcHandle = GCHandle.Alloc(this.nativeInterceptor, GCHandleType.Normal); this.credentials = Native.grpcsharp_metadata_credentials_create_from_plugin(nativeInterceptor); }
public void FromCredential() { Assert.Null(CallSettings.FromCallCredentials(null)); AsyncAuthInterceptor interceptor = (context, metadata) => Task.Delay(0); var credential = CallCredentials.FromInterceptor(interceptor); var settings = CallSettings.FromCallCredentials(credential); Assert.Same(credential, settings.Credentials); }
public NativeMetadataCredentialsPlugin(AsyncAuthInterceptor interceptor) { this.interceptor = Preconditions.CheckNotNull(interceptor, "interceptor"); this.nativeInterceptor = NativeMetadataInterceptorHandler; // Make sure the callback doesn't get garbage collected until it is destroyed. this.gcHandle = GCHandle.Alloc(this.nativeInterceptor, GCHandleType.Normal); this.credentials = grpcsharp_metadata_credentials_create_from_plugin(nativeInterceptor); }
public MacaroonCallCredentials(string macaroon) { var asyncAuthInterceptor = new AsyncAuthInterceptor(async(context, metadata) => { await Task.Delay(100).ConfigureAwait(false); metadata.Add("macaroon", macaroon); }); credentials = CallCredentials.FromInterceptor(asyncAuthInterceptor); }
public void FromCredential() { #pragma warning disable CS0618 // Type or member is obsolete Assert.Null(CallSettings.FromCallCredentials(null)); AsyncAuthInterceptor interceptor = (context, metadata) => Task.Delay(0); var credential = CallCredentials.FromInterceptor(interceptor); var settings = CallSettings.FromCallCredentials(credential); Assert.Same(credential, settings.Credentials); #pragma warning restore CS0618 // Type or member is obsolete }
public static void Main(string[] args) { var apiKey = "Pj+GIg2/l7ZKmicZi37+1giqKJ1WH3Vt8vSSxCuvPkKD"; var email = "*****@*****.**"; AsyncAuthInterceptor authInterceptor = new AsyncAuthInterceptor((context, metadata) => { metadata.Add("Authorization", "Bearer " + apiKey); return(Task.FromResult(0)); }); var channelCredentials = ChannelCredentials.Create(new SslCredentials(), CallCredentials.FromInterceptor(authInterceptor)); Channel channel = new Channel("api.staging.autheid.com", channelCredentials); var client = new Requests.RequestsClient(channel); var request = new CreateRequest(); request.Email = email; request.Title = "test"; request.Type = RequestType.Kyc; request.Kyc = new CreateRequest.Types.KYC(); request.Kyc.FilesFormat = FileFormat.Embedded; var reply = client.Create(request); Console.WriteLine("Request ID: " + reply.RequestId); var resultRequest = new GetResultRequest(); resultRequest.RequestId = reply.RequestId; var resultReply = client.GetResult(resultRequest); Console.WriteLine("Status: " + resultReply.Status); if (resultReply.Status == RequestStatus.Success) { Console.WriteLine("Fist Name: " + resultReply.Kyc.Identification.FirstName); Console.WriteLine("Last Name: " + resultReply.Kyc.Identification.LastName); Console.WriteLine("File size: " + resultReply.Kyc.KycPdf.Embedded.Length); // Create a new file using (FileStream fs = System.IO.File.Create("kyc.pdf")) { fs.Write(resultReply.Kyc.KycPdf.Embedded.ToByteArray(), 0, resultReply.Kyc.KycPdf.Embedded.Length); } } channel.ShutdownAsync().Wait(); Console.WriteLine("Press any key to exit..."); Console.ReadKey(); }
public void WithCallCredentials_NullSettings() { CallSettings noSettings = null; Assert.Null(noSettings.WithCallCredentials(null)); AsyncAuthInterceptor interceptor = (context, metadata) => Task.Delay(0); var credentials = CallCredentials.FromInterceptor(interceptor); var result = noSettings.WithCallCredentials(credentials); Assert.Same(credentials, result.Credentials); }
public void InterceptorDoesNothingForEmptyAccessTokens() { AsyncAuthInterceptor asyncAuthInterceptor = LedgerCallCredentials.MakeAsyncAuthInterceptor(new List <string>()); Metadata metaData = new Metadata(); Task task = asyncAuthInterceptor(new AuthInterceptorContext("url", "method"), metaData); task.IsCompleted.Should().BeTrue(); metaData.Should().BeEmpty(); }
public void InterceptorDoesNothingForEmptyAccessTokens() { AsyncAuthInterceptor asyncAuthInterceptor = LedgerCallCredentials.MakeAsyncAuthInterceptor(new List <string>()); Metadata metaData = new Metadata(); Task task = asyncAuthInterceptor(new AuthInterceptorContext("url", "method"), metaData); Assert.IsTrue(task.IsCompleted); Assert.AreEqual(0, metaData.Count); }
public void WithCallCredentials_NullCredentials() { AsyncAuthInterceptor interceptor = (context, metadata) => Task.Delay(0); var credentials = CallCredentials.FromInterceptor(interceptor); CancellationToken token = new CancellationTokenSource().Token; var original = new CallSettings(token, credentials, null, null, null, null); var result = original.WithCallCredentials(null); Assert.Null(result.Credentials); Assert.Equal(token, result.CancellationToken); }
public void WithCallCredentials_NullSettings() { CallSettings noSettings = null; #pragma warning disable CS0618 // Type or member is obsolete Assert.Null(noSettings.WithCallCredentials(null)); AsyncAuthInterceptor interceptor = (context, metadata) => Task.Delay(0); var credentials = CallCredentials.FromInterceptor(interceptor); var result = noSettings.WithCallCredentials(credentials); Assert.Same(credentials, result.Credentials); #pragma warning restore CS0618 // Type or member is obsolete }
public void WithCallCredentials_NullCredentials() { AsyncAuthInterceptor interceptor = (context, metadata) => Task.Delay(0); var credentials = CallCredentials.FromInterceptor(interceptor); CancellationToken token = new CancellationTokenSource().Token; #pragma warning disable CS0618 // Type or member is obsolete var original = new CallSettings(token, credentials, null, null, null, null, null); var result = original.WithCallCredentials(null); Assert.Null(result.Credentials); #pragma warning restore CS0618 // Type or member is obsolete Assert.Equal(token, result.CancellationToken); }
public void CanCreateAuthInterceptorForAccessToken() { AsyncAuthInterceptor asyncAuthInterceptor = LedgerCallCredentials.MakeAsyncAuthInterceptor("myAccessToken"); Metadata metaData = new Metadata(); Task task = asyncAuthInterceptor(new AuthInterceptorContext("url", "method"), metaData); task.IsCompleted.Should().BeTrue(); metaData.Should().ContainSingle(); var entry = metaData.First(); entry.Key.Should().Be("authorization"); entry.Value.Should().Be("myAccessToken"); }
public void CanCreateAuthInterceptorForAccessToken() { AsyncAuthInterceptor asyncAuthInterceptor = LedgerCallCredentials.MakeAsyncAuthInterceptor("myAccessToken"); Metadata metaData = new Metadata(); Task task = asyncAuthInterceptor(new AuthInterceptorContext("url", "method"), metaData); Assert.IsTrue(task.IsCompleted); Assert.AreEqual(1, metaData.Count); var entry = metaData.First(); Assert.AreEqual("authorization", entry.Key); Assert.AreEqual("myAccessToken", entry.Value); }
public RestChannel(RestServiceCollection serviceCollection, string endpoint, ChannelCredentials credentials, GrpcChannelOptions options) : base(endpoint) { _serviceCollection = serviceCollection; // Reuse a single CallInvoker however many times CreateCallInvoker is called. _callInvoker = new RestCallInvoker(this); // TODO: Handle endpoints better... // TODO: Avoid creating an HTTP Client for every channel? _httpClient = new HttpClient { BaseAddress = new Uri($"https://{endpoint}") }; _channelAuthInterceptor = credentials.ToAsyncAuthInterceptor(); // TODO: Use options where appropriate. }
private static AsyncAuthInterceptor GetAsyncAuthInterceptor() { var asyncAuthInterceptor = new AsyncAuthInterceptor((context, metadata) => { if (string.IsNullOrEmpty(_token)) { return(Task.CompletedTask); } metadata.Add(GrpcHelper.HeaderKey.Login, _login); metadata.Add(GrpcHelper.HeaderKey.Token, $"Bearer {_token}"); return(Task.CompletedTask); }); return(asyncAuthInterceptor); }
public void InterceptorCopesWithSparseAccessTokens() { AsyncAuthInterceptor asyncAuthInterceptor = LedgerCallCredentials.MakeAsyncAuthInterceptor(new[] { "accessToken1", null, "accessToken2", string.Empty, "accessToken3" }); Metadata metaData = new Metadata(); Task task = asyncAuthInterceptor(new AuthInterceptorContext("url", "method"), metaData); Assert.IsTrue(task.IsCompleted); int i = 1; foreach (var entry in metaData) { Assert.AreEqual("authorization", entry.Key); Assert.AreEqual($"accessToken{i++}", entry.Value); } }
public void CanCreateAuthInterceptorForAccessTokens() { AsyncAuthInterceptor asyncAuthInterceptor = LedgerCallCredentials.MakeAsyncAuthInterceptor(new [] { "accessToken1", "accessToken2", "accessToken3" }); Metadata metaData = new Metadata(); Task task = asyncAuthInterceptor(new AuthInterceptorContext("url", "method"), metaData); task.IsCompleted.Should().BeTrue(); metaData.Should().HaveCount(3); int i = 1; foreach (var entry in metaData) { entry.Key.Should().Be("authorization"); entry.Value.Should().Be($"accessToken{i++}"); } }
public Lightning(string tlsLocation, string macaroonLocation, string ip) { tls = File.ReadAllText(tlsLocation); sslCreds = new SslCredentials(tls); byte[] macaroonBytes = File.ReadAllBytes(macaroonLocation); macaroon = BitConverter.ToString(macaroonBytes).Replace("-", ""); // hex format stripped of "-" chars Task AddMacaroon(AuthInterceptorContext context, Metadata metadata) { metadata.Add(new Metadata.Entry("macaroon", macaroon)); return(Task.CompletedTask); } var macaroonInterceptor = new AsyncAuthInterceptor(AddMacaroon); var combinedCreds = ChannelCredentials.Create(sslCreds, CallCredentials.FromInterceptor(macaroonInterceptor)); var channel = new Grpc.Core.Channel(ip, combinedCreds); client = new Lnrpc.Lightning.LightningClient(channel); }
public void Init() { server = new Server { Services = { TestService.BindService(new FakeTestService()) }, Ports = { { Host, ServerPort.PickUnused, TestCredentials.CreateSslServerCredentials() } } }; server.Start(); options = new List<ChannelOption> { new ChannelOption(ChannelOptions.SslTargetNameOverride, TestCredentials.DefaultHostOverride) }; asyncAuthInterceptor = new AsyncAuthInterceptor(async (context, metadata) => { await Task.Delay(100).ConfigureAwait(false); // make sure the operation is asynchronous. metadata.Add("authorization", "SECRET_TOKEN"); }); }
public void Init() { server = new Server { Services = { TestService.BindService(new FakeTestService()) }, Ports = { { Host, ServerPort.PickUnused, TestCredentials.CreateSslServerCredentials() } } }; server.Start(); options = new List <ChannelOption> { new ChannelOption(ChannelOptions.SslTargetNameOverride, TestCredentials.DefaultHostOverride) }; asyncAuthInterceptor = new AsyncAuthInterceptor(async(context, metadata) => { await Task.Delay(100).ConfigureAwait(false); // make sure the operation is asynchronous. metadata.Add("authorization", "SECRET_TOKEN"); }); }
public void Init() { // Disable SO_REUSEPORT to prevent https://github.com/grpc/grpc/issues/10755 server = new Server(new[] { new ChannelOption(ChannelOptions.SoReuseport, 0) }) { Services = { TestService.BindService(new FakeTestService()) }, Ports = { { Host, ServerPort.PickUnused, TestCredentials.CreateSslServerCredentials() } } }; server.Start(); options = new List <ChannelOption> { new ChannelOption(ChannelOptions.SslTargetNameOverride, TestCredentials.DefaultHostOverride) }; asyncAuthInterceptor = new AsyncAuthInterceptor(async(context, metadata) => { await Task.Delay(100).ConfigureAwait(false); // make sure the operation is asynchronous. metadata.Add("authorization", "SECRET_TOKEN"); }); }
public void MetadataCredentials_PerCall() { serviceImpl.UnaryCallHandler = (req, context) => { var authToken = context.RequestHeaders.First((entry) => entry.Key == "authorization").Value; Assert.AreEqual("SECRET_TOKEN", authToken); return(Task.FromResult(new SimpleResponse())); }; var asyncAuthInterceptor = new AsyncAuthInterceptor(async(context, metadata) => { await Task.Delay(100).ConfigureAwait(false); // make sure the operation is asynchronous. metadata.Add("authorization", "SECRET_TOKEN"); }); channel = new Channel(Host, server.Ports.Single().BoundPort, TestCredentials.CreateSslCredentials(), options); client = new TestService.TestServiceClient(channel); var callCredentials = CallCredentials.FromInterceptor(asyncAuthInterceptor); client.UnaryCall(new SimpleRequest { }, new CallOptions(credentials: callCredentials)); }
public void Init() { serviceMock = new Mock <TestService.ITestService>(); serviceMock.Setup(m => m.UnaryCall(It.IsAny <SimpleRequest>(), It.IsAny <ServerCallContext>())) .Returns(new Func <SimpleRequest, ServerCallContext, Task <SimpleResponse> >(UnaryCallHandler)); server = new Server { Services = { TestService.BindService(serviceMock.Object) }, Ports = { { Host, ServerPort.PickUnused, TestCredentials.CreateSslServerCredentials() } } }; server.Start(); options = new List <ChannelOption> { new ChannelOption(ChannelOptions.SslTargetNameOverride, TestCredentials.DefaultHostOverride) }; asyncAuthInterceptor = new AsyncAuthInterceptor(async(context, metadata) => { await Task.Delay(100).ConfigureAwait(false); // make sure the operation is asynchronous. metadata.Add("authorization", "SECRET_TOKEN"); }); }
public void Init() { serviceMock = new Mock<TestService.ITestService>(); serviceMock.Setup(m => m.UnaryCall(It.IsAny<SimpleRequest>(), It.IsAny<ServerCallContext>())) .Returns(new Func<SimpleRequest, ServerCallContext, Task<SimpleResponse>>(UnaryCallHandler)); server = new Server { Services = { TestService.BindService(serviceMock.Object) }, Ports = { { Host, ServerPort.PickUnused, TestCredentials.CreateSslServerCredentials() } } }; server.Start(); options = new List<ChannelOption> { new ChannelOption(ChannelOptions.SslTargetNameOverride, TestCredentials.DefaultHostOverride) }; asyncAuthInterceptor = new AsyncAuthInterceptor(async (context, metadata) => { await Task.Delay(100).ConfigureAwait(false); // make sure the operation is asynchronous. metadata.Add("authorization", "SECRET_TOKEN"); }); }
public NativeMetadataCredentialsPlugin(AsyncAuthInterceptor interceptor) { this.interceptor = GrpcPreconditions.CheckNotNull(interceptor, "interceptor"); this.callbackRegistration = NativeCallbackDispatcher.RegisterCallback(HandleUniversalCallback); this.credentials = Native.grpcsharp_metadata_credentials_create_from_plugin(this.callbackRegistration.Tag); }
/// <summary> /// Initializes a new instance of <c>MetadataCredentials</c> class. /// </summary> /// <param name="interceptor">authentication interceptor</param> public MetadataCredentials(AsyncAuthInterceptor interceptor) { this.interceptor = interceptor; }
public override void SetAsyncAuthInterceptorCredentials(object state, AsyncAuthInterceptor interceptor) { Interceptor = interceptor; }
/// <summary> /// Initializes a new instance of <c>MetadataCredentials</c> class. /// </summary> /// <param name="interceptor">authentication interceptor</param> public MetadataCredentials(AsyncAuthInterceptor interceptor) { this.interceptor = GrpcPreconditions.CheckNotNull(interceptor); }
/// <summary> /// Creates a new instance of <c>CallCredentials</c> class from an /// interceptor that can attach metadata to outgoing calls. /// </summary> /// <param name="interceptor">authentication interceptor</param> public static CallCredentials FromInterceptor(AsyncAuthInterceptor interceptor) { return(new MetadataCredentials(interceptor)); }
/// <summary> /// Initializes a new instance of <c>MetadataCredentials</c> class. /// </summary> /// <param name="interceptor">authentication interceptor</param> public MetadataCredentials(AsyncAuthInterceptor interceptor) { this.interceptor = Preconditions.CheckNotNull(interceptor); }
/// <summary> /// Creates a new instance of <c>CallCredentials</c> class from an /// interceptor that can attach metadata to outgoing calls. /// </summary> /// <param name="interceptor">authentication interceptor</param> public static CallCredentials FromInterceptor(AsyncAuthInterceptor interceptor) { return new MetadataCredentials(interceptor); }