private async Task <CreateSessionResponse> CreateSessionAsyncInternalAsync(
Context context,
string name,
string cacheName,
ImplicitPin implicitPin,
string?serializedConfig,
string?pat)
{
Func <Task <CreateSessionResponse> > func = async() =>
{
var request = new CreateSessionRequest
{
CacheName = cacheName,
SessionName = name,
ImplicitPin = (int)implicitPin,
TraceId = context.TraceId,
Capabilities = (int)_clientCapabilities,
// Protobuff does not support setting null values.
SerializedConfig = serializedConfig ?? string.Empty,
Pat = pat ?? string.Empty
};
return(await CreateSessionAsync(request));
};
CreateSessionResponse response = await SendGrpcRequestAsync(context, func);
return(response);
}
/// <summary>
/// Implements a create session request.
/// </summary>
public async Task <CreateSessionResponse> CreateSessionAsync(CreateSessionRequest request, CancellationToken token)
{
LogRequestHandling();
var cacheContext = new Context(new Guid(request.TraceId), _logger);
var sessionCreationResult = await _sessionHandler.CreateSessionAsync(
new OperationContext(cacheContext, token),
request.SessionName,
request.CacheName,
(ImplicitPin)request.ImplicitPin,
(Capabilities)request.Capabilities);
if (sessionCreationResult)
{
return(new CreateSessionResponse()
{
SessionId = sessionCreationResult.Value.sessionId,
TempDirectory = sessionCreationResult.Value.tempDirectory.Path
});
}
else
{
return(new CreateSessionResponse()
{
ErrorMessage = sessionCreationResult.ErrorMessage
});
}
}
public void ExecuteSql()
{
Session session;
{
CreateSessionRequest request = new CreateSessionRequest
{
Database = DatabaseUrl
};
session = client.CreateSession(request);
Assert.IsNotNull(session);
AssertAffinityCount(1);
}
{
ExecuteSqlRequest request = new ExecuteSqlRequest
{
Session = session.Name,
Sql = string.Format("select id, data from {0}", TableName)
};
ResultSet resultSet = client.ExecuteSql(request);
AssertAffinityCount(1);
Assert.IsNotNull(resultSet);
Assert.AreEqual(1, resultSet.Rows.Count);
Assert.AreEqual(ColumnId, resultSet.Rows[0].Values[0].StringValue);
}
{
DeleteSessionRequest request = new DeleteSessionRequest
{
Name = session.Name
};
client.DeleteSession(request);
AssertAffinityCount(0);
}
}
/// <summary>
/// Creates a new session in a bastion. A bastion session lets authorized users connect to a target resource for a predetermined amount of time. The Bastion service recognizes two types of sessions, managed SSH sessions and SSH port forwarding sessions. Managed SSH sessions require that the target resource has an OpenSSH server and the Oracle Cloud Agent both running.
///
/// </summary>
/// <param name="request">The request object containing the details to send. Required.</param>
/// <param name="retryConfiguration">The retry configuration that will be used by to send this request. Optional.</param>
/// <param name="cancellationToken">The cancellation token to cancel this operation. Optional.</param>
/// <returns>A response object containing details about the completed operation</returns>
/// <example>Click <a href="https://docs.cloud.oracle.com/en-us/iaas/tools/dot-net-examples/latest/bastion/CreateSession.cs.html">here</a> to see an example of how to use CreateSession API.</example>
public async Task <CreateSessionResponse> CreateSession(CreateSessionRequest request, RetryConfiguration retryConfiguration = null, CancellationToken cancellationToken = default)
{
logger.Trace("Called createSession");
Uri uri = new Uri(this.restClient.GetEndpoint(), System.IO.Path.Combine(basePathWithoutHost, "/sessions".Trim('/')));
HttpMethod method = new HttpMethod("POST");
HttpRequestMessage requestMessage = Converter.ToHttpRequestMessage(uri, method, request);
requestMessage.Headers.Add("Accept", "application/json");
GenericRetrier retryingClient = Retrier.GetPreferredRetrier(retryConfiguration, this.retryConfiguration);
HttpResponseMessage responseMessage;
try
{
if (retryingClient != null)
{
responseMessage = await retryingClient.MakeRetryingCall(this.restClient.HttpSend, requestMessage, cancellationToken).ConfigureAwait(false);
}
else
{
responseMessage = await this.restClient.HttpSend(requestMessage).ConfigureAwait(false);
}
this.restClient.CheckHttpResponseMessage(requestMessage, responseMessage);
return(Converter.FromHttpResponseMessage <CreateSessionResponse>(responseMessage));
}
catch (Exception e)
{
logger.Error($"CreateSession failed with error: {e.Message}");
throw;
}
}
public async Task DelegateAValidPostToRequestExecutorGivenACreateSessionRequest()
{
var mockRequestExecutor = Substitute.For <IRequestExecutor>();
mockRequestExecutor
.PostAsync(Arg.Any <string>(), Arg.Any <IEnumerable <KeyValuePair <string, string> > >(), Arg.Any <string>(), Arg.Any <CancellationToken>())
.Returns(new HttpResponse <string>()
{
StatusCode = 200
});
var dataStore = new DefaultDataStore(mockRequestExecutor, new DefaultSerializer(), new ResourceFactory(null, null), NullLogger.Instance);
var createSessionRequest = new CreateSessionRequest()
{
SessionToken = "foo",
};
var client = new TestableOktaClient(mockRequestExecutor);
await client.Sessions.CreateSessionAsync(createSessionRequest);
await mockRequestExecutor.Received().PostAsync(
"/api/v1/sessions",
Arg.Any <IEnumerable <KeyValuePair <string, string> > >(),
"{\"sessionToken\":\"foo\"}",
CancellationToken.None);
}
public Task <CreateSessionResponse> CreateSession(CreateSessionRequest request)
{
return(Task.FromResult <CreateSessionResponse>(new CreateSessionResponse()
{
Id = "fake_session", CreatedAt = "fake"
}));
}
public async Task <IActionResult> Post([FromBody] CreateSessionModel model)
{
var request = new CreateSessionRequest(model);
var result = await _mediator.Send(request);
return(Ok(result));
}
/// <summary>
/// Login an Ampla users using username and password
/// </summary>
/// <param name="userName"></param>
/// <param name="password"></param>
/// <param name="message"></param>
/// <returns></returns>
public AmplaUser SimpleLogin(string userName, string password, out string message)
{
message = null;
AmplaUser user = amplaUserStore.GetUserByName(userName);
if (user != null)
{
user = Renew(user);
}
if (user == null)
{
CreateSessionRequest request = new CreateSessionRequest {
Username = userName, Password = password
};
Exception exception;
CreateSessionResponse response = CatchExceptions(() => securityWebService.CreateSession(request), out exception);
if (response != null)
{
user = new AmplaUser(response.Session.User, response.Session.SessionID, true, "Username/Password");
amplaUserStore.StoreUser(user);
}
if (user == null)
{
message = exception.Message;
}
}
return(user);
}
private async Task <long?> CreateSession()
{
var request = new CreateSessionRequest(RandomString());
_logger.Trace($"Janus create session request: {JsonConvert.SerializeObject(request)}");
return((Send <SuccessJanus>(request)).Data.Id);
}
/*
* Create a Session from client
*/
public static Session StartSession(Spanner.SpannerClient client)
{
CreateSessionRequest createSessionRequest = new CreateSessionRequest();
createSessionRequest.Database = _DATABASE;
return(client.CreateSession(createSessionRequest));
}
public AmplaUser IntegratedLogin(out string message)
{
message = null;
AmplaUser user = FindCurrentUser();
if (user != null)
{
user = Renew(user);
}
if (user == null)
{
CreateSessionRequest request = new CreateSessionRequest();
Exception exception;
CreateSessionResponse response = CatchExceptions(() => securityWebService.CreateSession(request), out exception);
if (response != null)
{
user = new AmplaUser(response.Session.User, response.Session.SessionID, true, "Integrated");
amplaUserStore.StoreUser(user);
}
if (user == null)
{
message = exception.Message;
}
}
return(user);
}
public Task <CreateSessionResponse> CreateSession(CreateSessionRequest request)
{
var client = restClientBuilder.Build();
var restRequest = new RestRequest("/api/sessions", DataFormat.Json);
return(client.PostAsync <CreateSessionResponse>(restRequest));
}
public async Task <string> CreateUserSession(CreateSessionRequest request)
{
if (request == null)
{
request = new CreateSessionRequest();
}
//Create new Session here
var dfcUserSession = _sessionClient.NewSession();
dfcUserSession.Origin = Origin.MatchSkills;
_sessionClient.CreateCookie(dfcUserSession, true);
var userSession = new UserSession()
{
UserSessionId = dfcUserSession.SessionId,
PartitionKey = dfcUserSession.PartitionKey,
Salt = dfcUserSession.Salt,
CurrentPage = request.CurrentPage,
PreviousPage = request.PreviousPage,
UserHasWorkedBefore = request.UserHasWorkedBefore,
RouteIncludesDysac = request.RouteIncludesDysac,
LastUpdatedUtc = DateTime.UtcNow,
SessionCreatedDate = dfcUserSession.CreatedDate
};
var result = await _cosmosService.CreateItemAsync(userSession, CosmosCollection.Session);
return(result.IsSuccessStatusCode ? userSession.PrimaryKey : null);
}
public Session Login(CreateSessionRequest createSessionRequest)
{
return(_databaseContext.UseTransaction(transaction =>
{
var user = _userRepository.GetUserByEmail(createSessionRequest.Email, true, transaction);
if (user == null)
{
throw new Exception("User does not exist");
}
Debug.Assert(user.Id != null, "user.Id != null");
var login = _userRepository.GetLogin(user.Id.Value, transaction);
if (login == null)
{
throw new Exception("Login does not exist");
}
var hash = Hash(createSessionRequest.Password);
if (!login.Hash.SequenceEqual(hash))
{
throw new Exception("Password is not correct");
}
var session = CreateSession(user);
_sessionRepository.AddSession(session, transaction);
return session;
}));
}
public async Task StartAsync(string apiKey, Token installationToken)
{
var request = new CreateSessionRequest(apiKey);
var entities = await ApiClient.DoSignedApiRequestAsync(HttpMethod.Post, "session-server", installationToken, request);
ApiClient.Session = new Session(entities);
}
public async Task <ClientSession> AuthenticateAsync(string clientId, [FromBody] CreateSessionRequest request)
{
var clientSession = await _sessionClient.Authenticate(
clientId,
request.ClientInfo,
request.Ttl);
return(_mapper.Map <ClientSession>(clientSession));
}
public CreateSessionResponse CreateSession(CreateSessionRequest request)
{
if (request == null)
{
throw new ArgumentNullException("request");
}
return(SendPostRequest <CreateSessionRequest, CreateSessionResponse>(request, "CreateSession"));
}
public void CreateSession()
{
var request = new CreateSessionRequest(RawRequests.CreateSession);
request.Parse();
Assert.Equal("XXXXXX", request.Certificate);
Assert.Equal("XXXXXX", request.Proof);
Assert.Equal("0", request.GameId.ToString());
}
public async Task PostSession(CreateSessionRequest session)
{
_context.Sessions.Add(new Data.Session {
Title = session.Title,
Description = session.Description,
StartTime = session.StartTime,
EndTime = session.EndTime
});
await _context.SaveChangesAsync();
}
private void OnRailCreateSessionRequest(CreateSessionRequest result)
{
WeGameHelper.WriteDebugString(nameof(OnRailCreateSessionRequest));
if (!this._connectionStateMap.ContainsKey((RailID)result.remote_peer) || this._connectionStateMap[(RailID)result.remote_peer] == NetSocialModule.ConnectionState.Inactive)
{
return;
}
WeGameHelper.WriteDebugString("AcceptSessionRequest, local{0}, remote:{1}", (object)(ulong)((RailComparableID)result.local_peer).id_, (object)(ulong)((RailComparableID)result.remote_peer).id_);
rail_api.RailFactory().RailNetworkHelper().AcceptSessionRequest((RailID)result.local_peer, (RailID)result.remote_peer);
}
private void OnRailCreateSessionRequest(CreateSessionRequest result)
{
//IL_0082: Unknown result type (might be due to invalid IL or missing references)
WeGameHelper.WriteDebugString("OnRailCreateSessionRequest");
if (_connectionStateMap.ContainsKey(result.remote_peer) && _connectionStateMap[result.remote_peer] != 0)
{
WeGameHelper.WriteDebugString("AcceptSessionRequest, local{0}, remote:{1}", ((RailComparableID)result.local_peer).id_, ((RailComparableID)result.remote_peer).id_);
rail_api.RailFactory().RailNetworkHelper().AcceptSessionRequest(result.local_peer, result.remote_peer);
}
}
public async Task <CreateSessionResponse> CreateSession(CreateSessionRequest request)
{
_createSessionRequestValidator.Validate(request);
var session = _createSessionRequestMapper.Map(request);
session = await _sessionRepository.Create(session);
return(_createSessionResponseMapper.Map(session));
}
public IActionResult ChangeSessionSpecialist([FromBody] CreateSessionRequest request, long id, long sessionID)
{
var user = UserService.Get(long.Parse(User.Identity.Name));
if (user == null)
{
return(NotFound(new ResponseModel
{
Success = false,
Message = "Пользователь не найден"
}));
}
var problem = ProblemService.Get(id);
if (problem == null)
{
return(NotFound(new ResponseModel
{
Success = false,
Message = "Проблема не найдена"
}));
}
var session = SessionService.Get(sessionID);
if (session == null)
{
return(NotFound(new ResponseModel
{
Success = false,
Message = "Сессия не найдена"
}));
}
var specialist = SpecialistService.Get(request.SpecialistID);
if (specialist == null)
{
return(NotFound(new ResponseModel
{
Success = false,
Message = "Специалист не найден"
}));
}
session.Specialist = specialist;
session.Reward = specialist.Price;
session.Status = SessionStatus.New;
SessionService.Update(session);
return(Ok(new ResponseModel()));
}
public async Task <ActionResult <CreateSessionResponse> > Create(CreateSessionRequest request)
{
var options = request.VotingOptions.Select(x => new Session.VoteOption(x.ToLower()));
var hostId = Guid.NewGuid();
var(sessionId, token) = await _sessionService.CreateSession(hostId, options.ToList());
return(new CreateSessionResponse {
SessionId = sessionId, UserId = hostId, AccessToken = new AccessToken(token)
});
}
public CreateSessionResponse CreateSession([FromBody] CreateSessionRequest request)
{
var session = DataContainer.CreateSession();
lock (session.Users) session.Users.Add(request.User);
return(new CreateSessionResponse()
{
SessionId = session.SessionId
});
}
private static async Task CreateSessionAsync()
{
//TODO: Add validation and failure handling
var request = new CreateSessionRequest()
{
ApiKey = AppacitiveContext.ApiKey
};
var response = await request.ExecuteAsync();
_sessionToken = response.Session.SessionKey;
}
public override async Task <Session> CreateSessionAsync(CreateSessionRequest request, CallSettings callSettings = null)
{
CheckFailAllRpcs();
await Scheduler.Delay(CreateSessionDelay);
int count = Interlocked.Increment(ref _sessionCounter);
var database = request.DatabaseAsDatabaseName;
return(new Session {
SessionName = new SessionName(database.ProjectId, database.InstanceId, database.DatabaseId, $"session-{count}")
});
}
public async Task <string> CreateSession(string name, bool subToNotifications, bool restrictAccess)
{
CreateSessionRequest req = new CreateSessionRequest
{
Name = name,
Notification = subToNotifications,
Restricted = restrictAccess
};
var response = await Post <CreateSessionRequest, CreateSessionResponse>("sessions", req);
return(response.Id);
}
public override async Task <IActionResult> Body()
{
var createSessionRequest = new CreateSessionRequest()
{
CurrentPage = CompositeViewModel.PageId.Worked.Value
};
await CreateUserSession(createSessionRequest);
ViewModel.HasError = HasErrors();
return(await base.Body());
}
public async Task <ActionResult <DownloadSession> > CreateSessionAsync(CreateSessionRequest request)
{
var __ = request;
var result = await _downloads.CreateSessionAsync(UserId);
if (!result.TryPickT0(out var session, out _))
{
return(ResultUtilities.BadRequest("Maximum number of download sessions has been reached."));
}
return(session.Convert());
}
protected override async Task OnOpenAsync(CancellationToken token)
{
await base.OnOpenAsync(token).ConfigureAwait(false);
token.ThrowIfCancellationRequested();
// if SessionId is provided then we skip the CreateSessionRequest and go directly to (re)ActivateSession.
// requires from previous Session: SessionId, AuthenticationToken, RemoteNonce
if (this.SessionId == null)
{
var localNonce = this.RemoteEndpoint.SecurityMode != MessageSecurityMode.None ? this.GetNextNonce() : null;
var localCertificateBlob = this.RemoteEndpoint.SecurityMode != MessageSecurityMode.None ? this.LocalCertificate.RawData : null;
var createSessionRequest = new CreateSessionRequest
{
RequestHeader = new RequestHeader { TimeoutHint = this.TimeoutHint, ReturnDiagnostics = this.DiagnosticsHint, Timestamp = DateTime.UtcNow },
ClientDescription = this.LocalDescription,
EndpointUrl = this.RemoteEndpoint.EndpointUrl,
SessionName = this.LocalDescription.ApplicationName,
ClientNonce = localNonce,
ClientCertificate = localCertificateBlob,
RequestedSessionTimeout = this.SessionTimeout,
MaxResponseMessageSize = this.RemoteMaxMessageSize
};
var createSessionResponse = (CreateSessionResponse)await this.RequestAsync(createSessionRequest).ConfigureAwait(false);
this.SessionId = createSessionResponse.SessionId;
this.AuthenticationToken = createSessionResponse.AuthenticationToken;
this.RemoteNonce = createSessionResponse.ServerNonce;
// verify the server's certificate is the same as the certificate from the selected endpoint.
if (this.RemoteEndpoint.ServerCertificate != null && !this.RemoteEndpoint.ServerCertificate.SequenceEqual(createSessionResponse.ServerCertificate))
{
throw new ServiceResultException(StatusCodes.BadCertificateInvalid, "Server did not return the same certificate used to create the channel.");
}
// verify the server's signature.
switch (this.RemoteEndpoint.SecurityPolicyUri)
{
case SecurityPolicyUris.Basic128Rsa15:
case SecurityPolicyUris.Basic256:
byte[] dataToVerify = Concat(localCertificateBlob, localNonce);
if (!this.RemotePublicKey.VerifyData(dataToVerify, createSessionResponse.ServerSignature.Signature, HashAlgorithmName.SHA1, RSASignaturePadding.Pkcs1))
{
throw new ServiceResultException(StatusCodes.BadApplicationSignatureInvalid, "Server did not provide a correct signature for the nonce data provided by the client.");
}
break;
case SecurityPolicyUris.Basic256Sha256:
byte[] dataToVerify256 = Concat(localCertificateBlob, localNonce);
if (!this.RemotePublicKey.VerifyData(dataToVerify256, createSessionResponse.ServerSignature.Signature, HashAlgorithmName.SHA256, RSASignaturePadding.Pkcs1))
{
throw new ServiceResultException(StatusCodes.BadApplicationSignatureInvalid, "Server did not provide a correct signature for the nonce data provided by the client.");
}
break;
default:
break;
}
}
// create client signature
SignatureData clientSignature = null;
switch (this.RemoteEndpoint.SecurityPolicyUri)
{
case SecurityPolicyUris.Basic128Rsa15:
case SecurityPolicyUris.Basic256:
byte[] dataToSign = Concat(this.RemoteEndpoint.ServerCertificate, this.RemoteNonce);
clientSignature = new SignatureData
{
Signature = this.LocalPrivateKey.SignData(dataToSign, HashAlgorithmName.SHA1, RSASignaturePadding.Pkcs1),
Algorithm = RsaSha1Signature,
};
break;
case SecurityPolicyUris.Basic256Sha256:
byte[] dataToSign256 = Concat(this.RemoteEndpoint.ServerCertificate, this.RemoteNonce);
clientSignature = new SignatureData
{
Signature = this.LocalPrivateKey.SignData(dataToSign256, HashAlgorithmName.SHA256, RSASignaturePadding.Pkcs1),
Algorithm = RsaSha256Signature,
};
break;
default:
clientSignature = new SignatureData();
break;
}
// supported UserIdentityToken types are AnonymousIdentityToken, UserNameIdentityToken, IssuedIdentityToken, X509IdentityToken
UserIdentityToken identityToken = null;
SignatureData tokenSignature = null;
// if UserIdentity type is IssuedIdentity
if (this.UserIdentity is IssuedIdentity)
{
var tokenPolicy = this.RemoteEndpoint.UserIdentityTokens.FirstOrDefault(t => t.TokenType == UserTokenType.IssuedToken);
if (tokenPolicy == null)
{
throw new ServiceResultException(StatusCodes.BadIdentityTokenRejected);
}
var issuedIdentity = (IssuedIdentity)this.UserIdentity;
byte[] plainText = Concat(issuedIdentity.TokenData, this.RemoteNonce);
var secPolicyUri = tokenPolicy.SecurityPolicyUri ?? this.RemoteEndpoint.SecurityPolicyUri;
RSA asymRemoteEncryptionKey;
switch (secPolicyUri)
{
case SecurityPolicyUris.Basic128Rsa15:
asymRemoteEncryptionKey = this.RemoteCertificate.GetRSAPublicKey();
identityToken = new IssuedIdentityToken
{
TokenData = asymRemoteEncryptionKey.EncryptTokenData(plainText, secPolicyUri),
EncryptionAlgorithm = RsaV15KeyWrap,
PolicyId = tokenPolicy.PolicyId
};
break;
case SecurityPolicyUris.Basic256:
case SecurityPolicyUris.Basic256Sha256:
asymRemoteEncryptionKey = this.RemoteCertificate.GetRSAPublicKey();
identityToken = new IssuedIdentityToken
{
TokenData = asymRemoteEncryptionKey.EncryptTokenData(plainText, secPolicyUri),
EncryptionAlgorithm = RsaOaepKeyWrap,
PolicyId = tokenPolicy.PolicyId
};
break;
default:
identityToken = new IssuedIdentityToken
{
TokenData = issuedIdentity.TokenData,
EncryptionAlgorithm = null,
PolicyId = tokenPolicy.PolicyId
};
break;
}
tokenSignature = new SignatureData();
}
// if UserIdentity type is X509Identity
else if (this.UserIdentity is X509Identity)
{
var tokenPolicy = this.RemoteEndpoint.UserIdentityTokens.FirstOrDefault(t => t.TokenType == UserTokenType.Certificate);
if (tokenPolicy == null)
{
throw new ServiceResultException(StatusCodes.BadIdentityTokenRejected);
}
var x509Identity = (X509Identity)this.UserIdentity;
identityToken = new X509IdentityToken { CertificateData = x509Identity.Certificate?.RawData, PolicyId = tokenPolicy.PolicyId };
var secPolicyUri = tokenPolicy.SecurityPolicyUri ?? this.RemoteEndpoint.SecurityPolicyUri;
switch (secPolicyUri)
{
case SecurityPolicyUris.Basic128Rsa15:
case SecurityPolicyUris.Basic256:
var asymSigningKey = x509Identity.Certificate?.GetRSAPrivateKey();
if (asymSigningKey != null)
{
byte[] dataToSign = Concat(this.RemoteEndpoint.ServerCertificate, this.RemoteNonce);
tokenSignature = new SignatureData
{
Signature = asymSigningKey.SignData(dataToSign, HashAlgorithmName.SHA1, RSASignaturePadding.Pkcs1),
Algorithm = RsaSha1Signature,
};
break;
}
tokenSignature = new SignatureData();
break;
case SecurityPolicyUris.Basic256Sha256:
var asymSigningKey256 = x509Identity.Certificate?.GetRSAPrivateKey();
if (asymSigningKey256 != null)
{
byte[] dataToSign256 = Concat(this.RemoteEndpoint.ServerCertificate, this.RemoteNonce);
tokenSignature = new SignatureData
{
Signature = asymSigningKey256.SignData(dataToSign256, HashAlgorithmName.SHA256, RSASignaturePadding.Pkcs1),
Algorithm = RsaSha256Signature,
};
break;
}
tokenSignature = new SignatureData();
break;
default:
tokenSignature = new SignatureData();
break;
}
}
// if UserIdentity type is UserNameIdentity
else if (this.UserIdentity is UserNameIdentity)
{
var tokenPolicy = this.RemoteEndpoint.UserIdentityTokens.FirstOrDefault(t => t.TokenType == UserTokenType.UserName);
if (tokenPolicy == null)
{
throw new ServiceResultException(StatusCodes.BadIdentityTokenRejected);
}
var userNameIdentity = (UserNameIdentity)this.UserIdentity;
byte[] plainText = Concat(System.Text.Encoding.UTF8.GetBytes(userNameIdentity.Password), this.RemoteNonce);
var secPolicyUri = tokenPolicy.SecurityPolicyUri ?? this.RemoteEndpoint.SecurityPolicyUri;
RSA asymRemoteEncryptionKey;
switch (secPolicyUri)
{
case SecurityPolicyUris.Basic128Rsa15:
asymRemoteEncryptionKey = this.RemoteCertificate.GetRSAPublicKey();
identityToken = new UserNameIdentityToken
{
UserName = userNameIdentity.UserName,
Password = asymRemoteEncryptionKey.EncryptTokenData(plainText, secPolicyUri),
EncryptionAlgorithm = RsaV15KeyWrap,
PolicyId = tokenPolicy.PolicyId
};
break;
case SecurityPolicyUris.Basic256:
case SecurityPolicyUris.Basic256Sha256:
asymRemoteEncryptionKey = this.RemoteCertificate.GetRSAPublicKey();
identityToken = new UserNameIdentityToken
{
UserName = userNameIdentity.UserName,
Password = asymRemoteEncryptionKey.EncryptTokenData(plainText, secPolicyUri),
EncryptionAlgorithm = RsaOaepKeyWrap,
PolicyId = tokenPolicy.PolicyId
};
break;
default:
identityToken = new UserNameIdentityToken
{
UserName = userNameIdentity.UserName,
Password = System.Text.Encoding.UTF8.GetBytes(userNameIdentity.Password),
EncryptionAlgorithm = null,
PolicyId = tokenPolicy.PolicyId
};
break;
}
tokenSignature = new SignatureData();
}
// if UserIdentity type is AnonymousIdentity or null
else
{
var tokenPolicy = this.RemoteEndpoint.UserIdentityTokens.FirstOrDefault(t => t.TokenType == UserTokenType.Anonymous);
if (tokenPolicy == null)
{
throw new ServiceResultException(StatusCodes.BadIdentityTokenRejected);
}
identityToken = new AnonymousIdentityToken { PolicyId = tokenPolicy.PolicyId };
tokenSignature = new SignatureData();
}
var activateSessionRequest = new ActivateSessionRequest
{
RequestHeader = new RequestHeader { TimeoutHint = this.TimeoutHint, ReturnDiagnostics = this.DiagnosticsHint, Timestamp = DateTime.UtcNow },
ClientSignature = clientSignature,
LocaleIds = new[] { CultureInfo.CurrentUICulture.TwoLetterISOLanguageName },
UserIdentityToken = identityToken,
UserTokenSignature = tokenSignature
};
var activateSessionResponse = (ActivateSessionResponse)await this.RequestAsync(activateSessionRequest).ConfigureAwait(false);
this.RemoteNonce = activateSessionResponse.ServerNonce;
await this.FetchNamespaceTablesAsync().ConfigureAwait(false);
}
/// <summary>
/// Initializes the message with the body.
/// </summary>
public CreateSessionMessage(CreateSessionRequest CreateSessionRequest)
{
this.CreateSessionRequest = CreateSessionRequest;
}
/// <summary>
/// Invokes the CreateSession service.
/// </summary>
public virtual ResponseHeader CreateSession(
RequestHeader requestHeader,
ApplicationDescription clientDescription,
string serverUri,
string endpointUrl,
string sessionName,
byte[] clientNonce,
byte[] clientCertificate,
double requestedSessionTimeout,
uint maxResponseMessageSize,
out NodeId sessionId,
out NodeId authenticationToken,
out double revisedSessionTimeout,
out byte[] serverNonce,
out byte[] serverCertificate,
out EndpointDescriptionCollection serverEndpoints,
out SignedSoftwareCertificateCollection serverSoftwareCertificates,
out SignatureData serverSignature,
out uint maxRequestMessageSize)
{
CreateSessionRequest request = new CreateSessionRequest();
CreateSessionResponse response = null;
request.RequestHeader = requestHeader;
request.ClientDescription = clientDescription;
request.ServerUri = serverUri;
request.EndpointUrl = endpointUrl;
request.SessionName = sessionName;
request.ClientNonce = clientNonce;
request.ClientCertificate = clientCertificate;
request.RequestedSessionTimeout = requestedSessionTimeout;
request.MaxResponseMessageSize = maxResponseMessageSize;
UpdateRequestHeader(request, requestHeader == null, "CreateSession");
try
{
if (UseTransportChannel)
{
IServiceResponse genericResponse = TransportChannel.SendRequest(request);
if (genericResponse == null)
{
throw new ServiceResultException(StatusCodes.BadUnknownResponse);
}
ValidateResponse(genericResponse.ResponseHeader);
response = (CreateSessionResponse)genericResponse;
}
else
{
CreateSessionResponseMessage responseMessage = InnerChannel.CreateSession(new CreateSessionMessage(request));
if (responseMessage == null || responseMessage.CreateSessionResponse == null)
{
throw new ServiceResultException(StatusCodes.BadUnknownResponse);
}
response = responseMessage.CreateSessionResponse;
ValidateResponse(response.ResponseHeader);
}
sessionId = response.SessionId;
authenticationToken = response.AuthenticationToken;
revisedSessionTimeout = response.RevisedSessionTimeout;
serverNonce = response.ServerNonce;
serverCertificate = response.ServerCertificate;
serverEndpoints = response.ServerEndpoints;
serverSoftwareCertificates = response.ServerSoftwareCertificates;
serverSignature = response.ServerSignature;
maxRequestMessageSize = response.MaxRequestMessageSize;
}
finally
{
RequestCompleted(request, response, "CreateSession");
}
return response.ResponseHeader;
}
/// <summary>
/// Begins an asynchronous invocation of the CreateSession service.
/// </summary>
public IAsyncResult BeginCreateSession(
RequestHeader requestHeader,
ApplicationDescription clientDescription,
string serverUri,
string endpointUrl,
string sessionName,
byte[] clientNonce,
byte[] clientCertificate,
double requestedSessionTimeout,
uint maxResponseMessageSize,
AsyncCallback callback,
object asyncState)
{
CreateSessionRequest request = new CreateSessionRequest();
request.RequestHeader = requestHeader;
request.ClientDescription = clientDescription;
request.ServerUri = serverUri;
request.EndpointUrl = endpointUrl;
request.SessionName = sessionName;
request.ClientNonce = clientNonce;
request.ClientCertificate = clientCertificate;
request.RequestedSessionTimeout = requestedSessionTimeout;
request.MaxResponseMessageSize = maxResponseMessageSize;
UpdateRequestHeader(request, requestHeader == null, "CreateSession");
if (UseTransportChannel)
{
return TransportChannel.BeginSendRequest(request, callback, asyncState);
}
return InnerChannel.BeginCreateSession(new CreateSessionMessage(request), callback, asyncState);
}
