public static void Main(string[] args)
{
const int Port = 9000;
var cacert = File.ReadAllText(@"ca.crt");
var cert = File.ReadAllText(@"server.crt");
var key = File.ReadAllText(@"server.key");
var keypair = new KeyCertificatePair(cert, key);
var sslCredentials = new SslServerCredentials(new List <KeyCertificatePair>()
{
keypair
}, cacert, false);
Server server = new Server
{
Services = { BindService(new EmployeeService()) },
Ports = { new ServerPort("0.0.0.0", Port, sslCredentials) }
};
server.Start();
Console.WriteLine("Starting server on port " + Port);
Console.WriteLine("Press any key to stop...");
Console.ReadKey();
server.ShutdownAsync().Wait();
}
private static async Task <Server> CreateServerAsync()
{
var host = "127.0.0.1";
var port = 40052;
await Console.Out.WriteLineAsync($"Starting Grpc server on {host}:{port}");
ServerCredentials credentials;
// HTTP connection, no auth token
// credentials = ServerCredentials.Insecure;
// HTTPS connection, no auth token
var certificateChain = await File.ReadAllTextAsync(@"certstrap-out\MyService.crt");
var privateKey = await File.ReadAllTextAsync(@"certstrap-out\MyService.key");
credentials = new SslServerCredentials(new[] { new KeyCertificatePair(certificateChain, privateKey) });
var server = new Server {
Services = { MyStackServer.BindService(new MyStackServerImpl()) },
Ports = { new ServerPort(host, port, credentials) }
};
return(server);
}
public async Task <ServerCredentials> Generate(string type, string configuration)
{
var sslConfiguration = JsonSerializerHelper.Deserialize <SSLConfiguration>(configuration);
var cacert = File.ReadAllText(sslConfiguration.CAFile);
var servercert = File.ReadAllText(sslConfiguration.ServerFile);
var serverkey = File.ReadAllText(sslConfiguration.KeyFile);
var keypair = new KeyCertificatePair(servercert, serverkey);
SslClientCertificateRequestType clientStrategy;
switch (sslConfiguration.ClientStrategy)
{
case 1:
clientStrategy = SslClientCertificateRequestType.DontRequest;
break;
default:
clientStrategy = SslClientCertificateRequestType.RequestAndRequireAndVerify;
break;
}
var sslCredentials = new SslServerCredentials(new List <KeyCertificatePair>()
{
keypair
}, cacert, clientStrategy);
return(await Task.FromResult(sslCredentials));
}
static void Main(string[] args)
{
const int Port = 9000;
var cacert = File.ReadAllText(@"certs/ca.crt");
var cert = File.ReadAllText(@"certs/server.crt");
var key = File.ReadAllText(@"certs/server.key");
var keypair = new KeyCertificatePair(cert, key);
var sslCredentials = new SslServerCredentials(new List <KeyCertificatePair>()
{
keypair
}, cacert, false);
Server server = new Server
{
Ports = //new ServerPort("0.0.0.0", Port, sslCredentials),
{
new ServerPort("[::]", Port, sslCredentials)
} // listening on IP6 port 9000
};
server.Services.Add(BindService(new EmployeeService()));
foreach (var service in server.Services)
{
Console.WriteLine($"Service: {service}");
}
server.Start();
Console.WriteLine($"Starting Server on port {Port}");
Console.WriteLine("Press any key to stop...");
Console.ReadKey();
server.ShutdownAsync().Wait();
}
/// <inheritdoc />
public void Start(IEnumerable <ServerServiceDefinition> services)
{
_logger.LogTrace($"[Grpc Server Layer. {_identity}] Запускается Grpc Server с конфигурацией: Host:{_config.Host.Hostname}; Port: {_config.Host.Port}; SSL: {_config.Ssl != null}");
var credentials = ServerCredentials.Insecure;
if (_config.Ssl != null)
{
var cacert = File.ReadAllText(Path.Combine(_config.Ssl.Path, _config.Ssl.CaCert));
var servercert = File.ReadAllText(Path.Combine(_config.Ssl.Path, _config.Ssl.CertificateChain));
var serverkey = File.ReadAllText(Path.Combine(_config.Ssl.Path, _config.Ssl.PrivateKey));
var keypair = new KeyCertificatePair(servercert, serverkey);
credentials = new SslServerCredentials(
new List <KeyCertificatePair> {
keypair
},
cacert,
SslClientCertificateRequestType.DontRequest);
}
_server = new Server(new[] { new ChannelOption(ChannelOptions.SoReuseport, 0) })
{
Ports = { new ServerPort(_config.Host.Hostname, _config.Host.Port, credentials) },
};
foreach (var definition in services)
{
_server.Services.Add(definition);
_logger.LogTrace($"[Grpc Server Layer. {_identity}] Добавляется конечная точка. {definition}");
}
_server.Start();
_logger.LogTrace($"[Grpc Server Layer. {_identity}] Grpc Server запущен.");
}
static void Main(string[] args)
{
var cacert = File.ReadAllText(@"..\certs\ca.crt");
var cert = File.ReadAllText(@"..\certs\server.crt");
var key = File.ReadAllText(@"..\certs\server.key");
var keypair = new KeyCertificatePair(cert, key);
var credentials = new SslServerCredentials(new List <KeyCertificatePair>
{
keypair
}, cacert, false);
Server server = new Server
{
Services = { KnockKnock.KnockKnockService.BindService(new KnockKnockService()) },
Ports = { new ServerPort("0.0.0.0", Port, credentials) }
};
server.Start();
Console.WriteLine("Knock Knock server listening on port " + Port);
Console.WriteLine("Press any key to stop the server...");
Console.ReadKey();
server.ShutdownAsync().Wait();
}
public static void Main(string[] args)
{
XmlConnector.Path = args.Length == 0 ? Directory.GetCurrentDirectory() : args[0];
var cacert = File.ReadAllText(@"/keys/ca.crt");
var servercert = File.ReadAllText(@"/keys/server.crt");
var serverkey = File.ReadAllText(@"/keys/server.key");
var keypair = new KeyCertificatePair(servercert, serverkey);
var sslCredentials = new SslServerCredentials(new List <KeyCertificatePair>()
{
keypair
}, cacert, false);
var transaqConnectorImpl = new TransaqConnectorImpl();
var server = new Server
{
Services = { TransaqConnector.BindService(transaqConnectorImpl) },
Ports = { new ServerPort("0.0.0.0", Port, sslCredentials) }
};
XmlConnector.Init(str =>
{
transaqConnectorImpl.OnMsg(str);
return(str);
});
server.Start();
Console.WriteLine("Greeter server listening on port " + Port);
Console.WriteLine("Press any key to stop the server...");
Console.ReadKey();
server.ShutdownAsync().Wait();
}
/// <summary>
/// init pem storage
/// and try to start servers if configuration set.
/// </summary>
/// <param name="dir"></param>
public void Init(string dir = "")
{
if (!GrpcLocalConfig.Instance.ParentChainServer && !GrpcLocalConfig.Instance.SideChainServer)
{
return;
}
try
{
_certificateStore = dir == "" ? _certificateStore : new CertificateStore(dir);
var keyCertificatePair = GenerateKeyCertificatePair();
// create credentials
_sslServerCredentials = new SslServerCredentials(new List <KeyCertificatePair> {
keyCertificatePair
});
}
catch (Exception e)
{
_logger.Error(e, "Exception while init ServerManager.");
throw;
}
// start servers if possible
StartSideChainServer();
StartParentChainServer();
}
public static void Main(string[] args)
{
//Environment.SetEnvironmentVariable("GRPC_TRACE", "all");
Environment.SetEnvironmentVariable("GRPC_VERBOSITY", "debug");
GrpcEnvironment.SetLogger(new ConsoleLogger());
//https://stackoverflow.com/questions/37714558/how-to-enable-server-side-ssl-for-grpc
var cacert = File.ReadAllText(@"C:\Users\ABOK078\Desktop\gRPC presentation\Grpc-Demo\cert\ca.crt");
var servercert = File.ReadAllText(@"C:\Users\ABOK078\Desktop\gRPC presentation\Grpc-Demo\cert\server.crt");
var serverkey = File.ReadAllText(@"C:\Users\ABOK078\Desktop\gRPC presentation\Grpc-Demo\cert\server.key");
var keypair = new KeyCertificatePair(servercert, serverkey);
var credentials = new SslServerCredentials(new[] { keypair }, cacert, true);
Server server = new Server
{
Services = { MarketData.BindService(new RandomMarketDataService()) },
//Ports = { new ServerPort("0.0.0.0", Port, ServerCredentials.Insecure) }
Ports = { new ServerPort("0.0.0.0", Port, credentials) }
};
server.Start();
Console.WriteLine("MarketData server listening on port " + Port);
Console.WriteLine("Press any key to stop the server...");
Console.ReadKey();
server.ShutdownAsync().Wait();
}
static void Main(string[] args)
{
const int port = 9000;
var cacert = File.ReadAllText("Keys/ca.crt");
var cert = File.ReadAllText("Keys/server.crt");
var key = File.ReadAllText("Keys/server.key");
var keypair = new KeyCertificatePair(cert, key);
var sslCreds = new SslServerCredentials(new List <KeyCertificatePair>
{
keypair
}, cacert, false);
Grpc.Core.Server server = new Grpc.Core.Server
{
Ports = { new ServerPort("0.0.0.0", port, sslCreds) },
Services = { BindService(new UsersService()) }
};
server.Start();
Console.WriteLine("Starting server on port " + port);
Console.WriteLine("Press any key to stop...");
Console.ReadKey();
}
static void StartServer(string host, int port)
{
var credentials = new SslServerCredentials(new List <KeyCertificatePair>
{
new KeyCertificatePair(
ResourceManager.GetText("Certificates.timecat.crt"),
ResourceManager.GetText("Certificates.timecat.key")
)
});
_server = new Server
{
Services =
{
RpcCategoryService.BindService(new CategoryService()),
RpcCommonService.BindService(new CommonService()),
RpcDashboardService.BindService(new DashboardService()),
RpcDetailService.BindService(new DetailService()),
RpcMainService.BindService(new MainService()),
RpcReviewService.BindService(new ReviewService())
},
Ports =
{
new ServerPort(host, port, credentials)
}
};
_server.Start();
Console.WriteLine($"Listening on {host}:{port}");
}
public static void Main(string[] args)
{
var cacert = File.ReadAllText(@"C:\Sertifika\ca.crt");
var servercert = File.ReadAllText(@"C:\Sertifika\server.crt");
var serverkey = File.ReadAllText(@"C:\Sertifika\server.key");
var keypair = new KeyCertificatePair(servercert, serverkey);
var sslCredentials = new SslServerCredentials(new List <KeyCertificatePair>()
{
keypair
}, cacert, false);
Server server = new Server
{
Services = { Greeter.BindService(new GreeterImpl()) },
Ports = { new ServerPort("localhost", Port, sslCredentials) }
};
server.Start();
Console.WriteLine("Greeter server listening on port " + Port);
Console.WriteLine("Press any key to stop the server...");
Console.ReadKey();
server.ShutdownAsync().Wait();
}
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 static void Start(IConfigurationRoot config)
{
var builder = new ContainerBuilder();
builder.RegisterInstance(config).As <IConfigurationRoot>();
//builder.RegisterInstance(new DataContext(config)).As<IDataContext>();
//builder.RegisterAssemblyTypes(typeof(IDataContext).GetTypeInfo().Assembly).Where(t => t.Name.EndsWith("Repository")).AsImplementedInterfaces();
_container = builder.Build();
var servercert = File.ReadAllText(@"server.crt");
var serverkey = File.ReadAllText(@"server.key");
var keypair = new KeyCertificatePair(servercert, serverkey);
var sslCredentials = new SslServerCredentials(new List <KeyCertificatePair>()
{
keypair
});
var healthService = new HealthServiceImpl();
_server = new Grpc.Core.Server
{
Services = { MsgService.BindService(new MsgServiceImpl()), Grpc.Health.V1.Health.BindService(healthService) },
Ports = { new ServerPort("0.0.0.0", 9007, sslCredentials) }
};
_server.Start();
healthService.SetStatus("Demo", Grpc.Health.V1.HealthCheckResponse.Types.ServingStatus.Serving);
_server.ShutdownTask.Wait();
}
/// <nodoc/>
internal void Start(int port, ServerServiceDefinition serverService)
{
var interceptor = new ServerInterceptor(m_loggingContext, m_invocationId);
ServerCredentials serverCreds = null;
if (GrpcSettings.EncryptionEnabled)
{
string certSubjectName = EngineEnvironmentSettings.CBBuildUserCertificateName;
if (GrpcEncryptionUtil.TryGetPublicAndPrivateKeys(certSubjectName, out string publicCertificate, out string privateKey, out var _) &&
publicCertificate != null &&
privateKey != null)
{
serverCreds = new SslServerCredentials(
new List <KeyCertificatePair> {
new KeyCertificatePair(publicCertificate, privateKey)
},
null,
SslClientCertificateRequestType.DontRequest);
Logger.Log.GrpcAuthTrace(m_loggingContext, $"Server-side SSL credentials is enabled.");
}
else
{
Logger.Log.GrpcAuthWarningTrace(m_loggingContext, $"Could not extract public certificate and private key from '{certSubjectName}'. Server will be started without ssl.");
}
}
public void Init()
{
var rootCert = File.ReadAllText(TestCredentials.ClientCertAuthorityPath);
var keyCertPair = new KeyCertificatePair(
File.ReadAllText(TestCredentials.ServerCertChainPath),
File.ReadAllText(TestCredentials.ServerPrivateKeyPath));
var serverCredentials = new SslServerCredentials(new[] { keyCertPair }, rootCert, true);
var clientCredentials = new SslCredentials(rootCert, keyCertPair);
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)
};
channel = new Channel(Host, server.Ports.Single().BoundPort, clientCredentials, options);
client = new TestService.TestServiceClient(channel);
}
public void InitClientAndServer(bool clientAddKeyCertPair,
SslClientCertificateRequestType clientCertRequestType,
VerifyPeerCallback verifyPeerCallback = null)
{
rootCert = File.ReadAllText(TestCredentials.ClientCertAuthorityPath);
keyCertPair = new KeyCertificatePair(
File.ReadAllText(TestCredentials.ServerCertChainPath),
File.ReadAllText(TestCredentials.ServerPrivateKeyPath));
var serverCredentials = new SslServerCredentials(new[] { keyCertPair }, rootCert, clientCertRequestType);
var clientCredentials = new SslCredentials(rootCert, clientAddKeyCertPair ? keyCertPair : null, verifyPeerCallback);
// 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 SslCredentialsTestServiceImpl()) },
Ports = { { Host, ServerPort.PickUnused, serverCredentials } }
};
server.Start();
var options = new List <ChannelOption>
{
new ChannelOption(ChannelOptions.SslTargetNameOverride, TestCredentials.DefaultHostOverride)
};
channel = new Channel(Host, server.Ports.Single().BoundPort, clientCredentials, options);
client = new TestService.TestServiceClient(channel);
}
/// <summary>
/// 使用ssl加密启动服务
/// 建议使用RSA 密钥长度可以为1024，2048 或者 4096 bits
/// 可以使用sslgen.cmd每次生成不同的密钥
/// </summary>
/// <param name="serverCertFile">共用证书</param>
/// <param name="privateKeyFile">私钥</param>
/// <param name="exceptionHandler"></param>
/// <returns></returns>
public bool StartWithSsl(string serverCertFile = "server.crt", string privateKeyFile = "server.key", Action <Exception> exceptionHandler = null)
{
try
{
////Server可以服务多个services，绑定多个端口
//Server server = new Server(options)
//{
// //可以注册多个service
// Services = { Greeter.BindService(new GreeterServiceImpl()), },
// //可以注册多个端口
// //0.0.0.0监听在本机的所有IP地址
// Ports = { new ServerPort(IPAddress.Any.ToString()/*0.0.0.0*/, Port, ServerCredentials.Insecure/*没有安全验证*/) },
//};
//Server可以定义多个服务，绑定多个端口
_server = new Server(GrpcOptions);
//添加多个服务
foreach (var serviceItem in _serviceList)
{
//服务实现抛出异常不会挂掉服务器，客户端捕获如下异常信息:Status(StatusCode=Unknown, Detail="Exception was thrown by handler.")
_server.Services.Add(serviceItem);
}
#region ssl加密
//证书链PEM encoded certificate chain 包含公钥 有效期 签发者等信息，但不包含私钥
string serverCert = File.ReadAllText(serverCertFile, Encoding.UTF8);
//私钥PEM encoded private key 不能公开，只有服务器上有
string privateKey = File.ReadAllText(privateKeyFile, Encoding.UTF8);
KeyCertificatePair keyPair = new KeyCertificatePair(serverCert, privateKey);
SslServerCredentials sslCredentials = new SslServerCredentials(new List <KeyCertificatePair>()
{
keyPair
});
#endregion
//添加多个监听端口
//0.0.0.0表示监听本机所有ip地址， 没有安全验证
//string ipAny = IPAddress.Any.ToString();
//ssl证书
_server.Ports.Add(this._bindIp, this._serverPort, sslCredentials);
_server.Start();
return(true);
}
catch (Exception e)
{
exceptionHandler?.Invoke(e);
return(false);
}
}
/// <summary>
/// Opens a connection using the parameters resolved by the referenced connection
/// resolver and creates a gRPC server(service) using the set options and parameters.
/// </summary>
/// <param name="correlationId">(optional) transaction id to trace execution through call chain.</param>
public virtual async Task OpenAsync(string correlationId)
{
if (IsOpen())
{
return;
}
var connection = await _connectionResolver.ResolveAsync(correlationId);
var credential = connection.GetSection("credential");
var protocol = connection.Protocol;
var host = connection.Host;
var port = connection.Port;
_address = protocol + "://" + host + ":" + port;
try
{
ServerCredentials serverCredentials = ServerCredentials.Insecure;
if (protocol == "https")
{
var sslKeyFile = credential.GetAsNullableString("ssl_key_file");
var privateKey = new StreamReader(sslKeyFile).ReadToEnd();
var sslCrtFile = credential.GetAsNullableString("ssl_crt_file");
var certificate = new StreamReader(sslCrtFile).ReadToEnd();
serverCredentials = new SslServerCredentials(new[] { new KeyCertificatePair(certificate, privateKey) });
}
_server = new Server
{
Ports = { new ServerPort(host, port, serverCredentials) }
};
_logger.Info(correlationId, "Opened gRPC service at {0}", _address);
PerformRegistrations();
_server.Start();
await Task.Delay(0);
}
catch (Exception ex)
{
if (_server != null)
{
//_server.Dispose();
_server = null;
}
throw new ConnectionException(correlationId, "CANNOT_CONNECT", "Opening gRPC service failed")
.WithCause(ex).WithDetails("url", _address);
}
}
public void Constructor_LegacyForceClientAuth()
{
var creds = new SslServerCredentials(new[] { keyCertPair }, rootCert, true);
Assert.AreEqual(SslClientCertificateRequestType.RequestAndRequireAndVerify, creds.ClientCertificateRequest);
var creds2 = new SslServerCredentials(new[] { keyCertPair }, rootCert, false);
Assert.AreEqual(SslClientCertificateRequestType.DontRequest, creds2.ClientCertificateRequest);
}
public void AddPort(string host, int port, string sslPublicKey, string sslPrivateKey)
{
var keyPair = new KeyCertificatePair(sslPublicKey, sslPrivateKey);
var sslCredentials = new SslServerCredentials(new List <KeyCertificatePair> {
keyPair
});
var serverPort = new ServerPort(host, port, sslCredentials);
Ports.Add(serverPort);
}
public static ServiceProxy CreateServiceProxy(string host, int port, string publicKey, string privateKey, params object[] instances)
{
var keyPair = new KeyCertificatePair(publicKey, privateKey);
var sslCredentials = new SslServerCredentials(new List <KeyCertificatePair> {
keyPair
});
ServerPort serverPort = new ServerPort(host, port, sslCredentials);
return(CreateServiceProxy(new List <ServerPort> {
serverPort
}, instances));
}
public EtgService(EntryDataServiceImpl entryDataServiceImpl, ILoggerFactory loggerFactory, IOptions <EtgServiceOptions> optionsAccessor)
{
this.securePorts = optionsAccessor.Value.SecureChannelPorts;
this.insecurePorts = optionsAccessor.Value.InsecureChannelPorts;
serverCredentials = new SslServerCredentials(
optionsAccessor.Value.ServerKeyCertPairs.Select(x => new KeyCertificatePair(x.Cert, x.Key)),
optionsAccessor.Value.CACert,
true);
this.entryDataServiceImpl = entryDataServiceImpl;
this.logger = loggerFactory.CreateLogger <EtgService>();
}
static void Main(string[] args)
{
Server server = null;
try
{
var serverCertificate = File.ReadAllText("ssl/server.crt");
var serverKey = File.ReadAllText("ssl/server.key");
var keyCertificatePair = new KeyCertificatePair(serverCertificate, serverKey);
var caCertificate = File.ReadAllText("ssl/ca.crt");
var credentials = new SslServerCredentials(new List <KeyCertificatePair>()
{
keyCertificatePair
}, caCertificate, true);
// ./evans.exe -r -p 50051
var greetingServiceReflectionServiceImpl = new ReflectionServiceImpl(GreetingService.Descriptor, ServerReflection.Descriptor);
var calculatorServiceReflectionServiceImpl = new ReflectionServiceImpl(CalculatorService.Descriptor, ServerReflection.Descriptor);
var blogServiceReflectionServiceImpl = new ReflectionServiceImpl(BlogService.Descriptor, ServerReflection.Descriptor);
server = new Server()
{
Services =
{
BlogService.BindService(new BlogServiceImpl()),
ServerReflection.BindService(blogServiceReflectionServiceImpl),
GreetingService.BindService(new GreetingServiceImpl()),
//ServerReflection.BindService(greetingServiceReflectionServiceImpl),
CalculatorService.BindService(new CalculatorServiceImpl()),
//ServerReflection.BindService(calculatorServiceReflectionServiceImpl)
},
Ports = { new ServerPort("localhost", port, ServerCredentials.Insecure) }
};
server.Start();
Console.WriteLine("The server is listening on the port :" + port);
Console.ReadKey();
}
catch (IOException e)
{
Console.WriteLine("The server failed to start:" + e.Message);
throw;
}
finally
{
if (server != null)
{
server.ShutdownAsync().Wait();
}
}
}
private static ServerCredentials GetServerCredentials(SslClientCertificateRequestType sslClientCertificateRequestType)
{
var rootCert = File.ReadAllText("keys/ca.crt");
var serverCert = File.ReadAllText("keys/server.crt");
var serverKey = File.ReadAllText("keys/server.key");
var credentials = new SslServerCredentials(
new[] { new KeyCertificatePair(serverCert, serverKey) },
rootCert,
sslClientCertificateRequestType
);
return(credentials);
}
static void Main(string[] args)
{
Server server = null;
try
{
var reflectionServiceImpl = new ReflectionServiceImpl(GreetingService.Descriptor, ServerReflection.Descriptor);
var serverCert = File.ReadAllText("ssl/server.crt");
var serverKey = File.ReadAllText("ssl/server.key");
var keypair = new KeyCertificatePair(serverCert, serverKey);
var cacert = File.ReadAllText("ssl/ca.crt");
var credentials = new SslServerCredentials(
new List <KeyCertificatePair>()
{
keypair
}, cacert, true);
server = new Server()
{
Services =
{
GreetingService.BindService(new GreetingServiceImp()),
CalculatorService.BindService(new CalculatorServiceImp()),
SqrtService.BindService(new SqrtServiceImpl()),
GreetDeadlinesService.BindService(new GreetingDeadlinesImpl()),
ServerReflection.BindService(reflectionServiceImpl)
},
Ports = { new ServerPort("localhost", Port, ServerCredentials.Insecure) }
};
server.Start();
Console.WriteLine("The server is listening on the port {0}", Port);
Console.ReadKey();
}
catch (IOException e)
{
Console.WriteLine("The server failed to start: ", e.Message);
}
finally
{
if (server != null)
{
server.ShutdownAsync().Wait();
}
}
}
static async Task <ServerPort> CreateSecureServerPort(string host, int port)
{
var serverCert = await File.ReadAllTextAsync("ssl/server.crt");
var serverKey = await File.ReadAllTextAsync("ssl/server.key");
var caCrt = await File.ReadAllTextAsync("ssl/ca.crt");
var credentials = new SslServerCredentials(new List <KeyCertificatePair> {
new KeyCertificatePair(serverCert, serverKey)
}, caCrt, true);
return(await CreateServerPort(host, port, credentials));
}
static void Main(string[] args)
{
Server server = null;
try
{
var serverCert = File.ReadAllText("ssl/server.crt");
var serverKey = File.ReadAllText("ssl/server.key");
var keypair = new KeyCertificatePair(serverCert, serverKey);
var caCrt = File.ReadAllText("ssl/ca.crt");
var credentials = new SslServerCredentials(new List <KeyCertificatePair>()
{
keypair
}, caCrt, true);
server = new Server()
{
Services =
{
GreetingService.BindService(new GreetingServiceImpl()),
SumService.BindService(new SumServiceImpl()),
PrimeNumbersService.BindService(new PrimeNumbersServiceImpl()),
AverageService.BindService(new AverageServiceImpl()),
MaxService.BindService(new MaxServiceImpl()),
SqrtService.BindService(new SquareRootServiceImpl()),
ServerReflection.BindService(new ReflectionServiceImpl(GreetingService.Descriptor, ServerReflection.Descriptor))
},
Ports = { new ServerPort("localhost", port, credentials) }
};
server.Start();
Console.WriteLine($"Server is listening on port: {port}");
Console.ReadKey();
}
catch (IOException e)
{
Console.WriteLine($"Server failed to start - {e.Message}");
throw;
}
finally
{
if (server != null)
{
server.ShutdownAsync().Wait();
}
}
}
static SslServerCredentials GetCerts()
{
var certsFolder = Path.Combine(Environment.CurrentDirectory, "Certs");
var cacert = File.ReadAllText(Path.Combine(certsFolder, "ca.crt"));
var cert = File.ReadAllText(Path.Combine(certsFolder, "server.crt"));
var key = File.ReadAllText(Path.Combine(certsFolder, "server.key"));
var certificateCollection = new List <KeyCertificatePair>
{
new KeyCertificatePair(cert, key)
};
var servCred = new SslServerCredentials(certificateCollection, cacert, SslClientCertificateRequestType.RequestAndRequireButDontVerify);
return(servCred);
}
public SslServerCredentials GetSslServerCredentials()
{
var caCert = File.ReadAllText(Path.Combine(Defines.CertFolderPath, Defines.CaCertificateName));
var cert = File.ReadAllText(Path.Combine(Defines.CertFolderPath, Defines.ServerCertificateName));
var key = File.ReadAllText(Path.Combine(Defines.CertFolderPath, Defines.ServerCertificateKeyName));
var certificateCollection = new List <KeyCertificatePair>
{
new KeyCertificatePair(cert, key)
};
var serverCredentials = new SslServerCredentials(certificateCollection, caCert, SslClientCertificateRequestType.RequestAndRequireButDontVerify);
return(serverCredentials);
}
