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);
}
