public void GetThreadContext(ContextFlags flags, int contextBufferSize, out int contextSize, IntPtr contextBuffer)
{
uint uContextSize = 0;
m_sw.GetContext((uint)flags, (uint)contextBufferSize, out uContextSize, contextBuffer);
contextSize = (int)uContextSize;
}
// returns the platform-specific Context Flags
public ContextFlags GetPSFlags(AgnosticContextFlags flags)
{
// We know that we need an x86 context
ContextFlags cFlags = ContextFlags.X86Context;
if ((flags & AgnosticContextFlags.ContextInteger) == AgnosticContextFlags.ContextInteger)
{
// ContextInteger is the same for all platforms, so we can do a blanket |=
cFlags |= (ContextFlags)AgnosticContextFlags.ContextInteger;
}
if ((flags & AgnosticContextFlags.ContextControl) == AgnosticContextFlags.ContextControl)
{
cFlags |= (ContextFlags)AgnosticContextFlags.ContextControl;
}
if ((flags & AgnosticContextFlags.ContextFloatingPoint) == AgnosticContextFlags.ContextFloatingPoint)
{
cFlags |= (ContextFlags)AgnosticContextFlags.ContextFloatingPoint;
}
if ((flags & AgnosticContextFlags.ContextAll) == AgnosticContextFlags.ContextAll)
{
// ContextAll is the same for all platforms, so we can do a blanket |=
cFlags |= (ContextFlags)AgnosticContextFlags.ContextAll;
}
return(cFlags);
}
private void CheckIfFlagWasObtainedIfRequested(ContextFlags flag)
{
if ((this.m_RequestedFlags & flag) != (ContextFlags)0 && (this.m_ContextFlags & (int)flag) == 0)
{
throw new AdomdConnectionException(XmlaSR.Authentication_Sspi_FlagNotEstablished(flag.ToString()), null, ConnectionExceptionCause.AuthenticationFailed);
}
}
internal NTAuthentication(bool isServer, string package, NetworkCredential credential, string spn, ContextFlags requestedContextFlags, ContextAwareResult context, System.Security.Authentication.ExtendedProtection.ChannelBinding channelBinding)
{
if ((credential is SystemNetworkCredential) && ComNetOS.IsWinNt)
{
WindowsIdentity identity = (context == null) ? null : context.Identity;
try
{
IDisposable disposable = (identity == null) ? null : identity.Impersonate();
if (disposable != null)
{
using (disposable)
{
this.Initialize(isServer, package, credential, spn, requestedContextFlags, channelBinding);
return;
}
}
ExecutionContext executionContext = (context == null) ? null : context.ContextCopy;
if (executionContext == null)
{
this.Initialize(isServer, package, credential, spn, requestedContextFlags, channelBinding);
}
else
{
ExecutionContext.Run(executionContext, s_InitializeCallback, new InitializeCallbackContext(this, isServer, package, credential, spn, requestedContextFlags, channelBinding));
}
return;
}
catch
{
throw;
}
}
this.Initialize(isServer, package, credential, spn, requestedContextFlags, channelBinding);
}
/// <summary>
/// Create a new instance of the GraphicsAPI struct.
/// </summary>
/// <param name="api">The context API to use.</param>
/// <param name="profile">The context profile to use.</param>
/// <param name="flags">The context flags to use.</param>
/// <param name="apiVersion">The API version to use.</param>
public GraphicsAPI(ContextAPI api, ContextProfile profile, ContextFlags flags, APIVersion apiVersion)
{
API = api;
Profile = profile;
Flags = flags;
Version = apiVersion;
}
/// <summary>
/// Populates the given transformation manager with O0 optimizations.
/// </summary>
/// <param name="builder">The transformation manager to populate.</param>
/// <param name="contextFlags">The context flags.</param>
public static void AddO0Optimizations(
this Transformer.Builder builder,
ContextFlags contextFlags)
{
builder.AddBasicOptimizations(contextFlags);
builder.AddAddressSpaceOptimizations();
}
// returns the platform-specific Context Flags
public ContextFlags GetPSFlags(AgnosticContextFlags flags)
{
// We know that we need an ia64 context
this.m_platform = Platform.IA64;
ContextFlags cFlags = ContextFlags.IA64Context;
if ((flags & AgnosticContextFlags.ContextInteger) == AgnosticContextFlags.ContextInteger)
{
// ContextInteger is the same for all platforms, so we can do a blanket |=
cFlags |= (ContextFlags)AgnosticContextFlags.ContextInteger;
}
if ((flags & AgnosticContextFlags.ContextControl) == AgnosticContextFlags.ContextControl)
{
// IA64 has a different flag for ContextControl
cFlags |= ContextFlags.IA64ContextControl;
}
if ((flags & AgnosticContextFlags.ContextFloatingPoint) == AgnosticContextFlags.ContextFloatingPoint)
{
// IA64 has a different flag for ContextFloatingPoint
cFlags |= ContextFlags.IA64ContextFloatingPoint;
}
if ((flags & AgnosticContextFlags.ContextAll) == AgnosticContextFlags.ContextAll)
{
// ContextAll is the same for all platforms, so we can do a blanket |=
cFlags |= (ContextFlags)AgnosticContextFlags.ContextAll;
}
return(cFlags);
}
public GPU(ContextFlags flags = ContextFlags.None, OptimizationLevel optimizationLevel = OptimizationLevel.Debug, bool forceCPU = false)
{
this.context = new Context(flags, optimizationLevel);
this.context.EnableAlgorithms();
this.accelerator = GetGpu(context, forceCPU);
Console.WriteLine("Device loaded: " + accelerator.Name);
}
public SpanContext(TraceId traceId, SpanId spanId = null, SpanId parentId = null, Dictionary <string, string> baggage = null, ContextFlags flags = ContextFlags.Sampled)
{
TraceId = traceId ?? throw new ArgumentNullException(nameof(traceId));
ParentId = parentId;
SpanId = spanId;
Flags = flags;
_baggage = baggage ?? new Dictionary <string, string>();
}
public Context GetContext(ContextFlags ctxFlags)
{
var ctx = new Context(ctxFlags);
if (!GetThreadContext(Handle, ctx.NativeHandle))
throw new Win32Exception();
return ctx;
}
/// <summary>
/// Gets the thread's context.
/// </summary>
/// <returns>A CONTEXT struct.</returns>
public Context GetContext(ContextFlags flags)
{
Context context = new Context();
context.ContextFlags = flags;
this.GetContext(ref context);
return(context);
}
/// <summary>
/// Constructs a new specializer configuration.
/// </summary>
/// <param name="flags">The associated context flags.</param>
/// <param name="abi">The ABI specification.</param>
/// <param name="contextData">The global PTX context data.</param>
public SpecializerConfiguration(
ContextFlags flags,
ABI abi,
PTXContextData contextData)
{
ContextFlags = flags;
ABI = abi;
ImplementationResolver = contextData.ImplementationResolver;
}
/// <summary>
/// Populates the given transformation manager with O0 optimizations.
/// </summary>
/// <param name="builder">The transformation manager to populate.</param>
/// <param name="contextFlags">The context flags.</param>
public static void AddO0Optimizations(
this Transformer.Builder builder,
ContextFlags contextFlags)
{
builder.AddBasicOptimizations(contextFlags);
builder.Add(new SSAConstruction());
builder.Add(new DeadCodeElimination());
builder.Add(new InferAddressSpaces());
}
/// <summary>
/// Creates a transformer for the given optimization level.
/// </summary>
/// <param name="level">The level.</param>
/// <param name="configuration">The transformer configuration.</param>
/// <param name="contextFlags">The context flags.</param>
/// <returns>The created transformer.</returns>
public static Transformer CreateTransformer(
this OptimizationLevel level,
TransformerConfiguration configuration,
ContextFlags contextFlags)
{
var builder = Transformer.CreateBuilder(configuration);
builder.AddOptimizations(contextFlags, level);
return(builder.ToTransformer());
}
internal static unsafe partial int AcceptSecurityContext(
ref CredHandle credentialHandle,
void *inContextPtr,
SecBufferDesc *inputBuffer,
ContextFlags inFlags,
Endianness endianness,
ref CredHandle outContextPtr,
ref SecBufferDesc outputBuffer,
ref ContextFlags attributes,
out long timeStamp);
internal InitializeCallbackContext(NTAuthentication thisPtr, bool isServer, string package, NetworkCredential credential, string spn, ContextFlags requestedContextFlags, ChannelBinding channelBinding)
{
this.thisPtr = thisPtr;
this.isServer = isServer;
this.package = package;
this.credential = credential;
this.spn = spn;
this.requestedContextFlags = requestedContextFlags;
this.channelBinding = channelBinding;
}
/// <summary>
/// Adds basic optimization transformations.
/// </summary>
/// <param name="builder">The transformation manager to populate.</param>
/// <param name="contextFlags">The context flags.</param>
public static void AddBasicOptimizations(
this Transformer.Builder builder,
ContextFlags contextFlags)
{
if (!contextFlags.HasFlags(ContextFlags.NoInlining))
{
builder.Add(new Inliner());
}
builder.Add(new SimplifyControlFlow());
}
/// <summary>
/// Populates the given transformation manager with O1 optimizations.
/// </summary>
/// <param name="builder">The transformation manager to populate.</param>
/// <param name="contextFlags">The context flags.</param>
public static void AddO1Optimizations(
this Transformer.Builder builder,
ContextFlags contextFlags)
{
builder.AddBasicOptimizations(contextFlags);
builder.AddStructureOptimizations();
builder.AddLoopOptimizations();
builder.AddConditionalOptimizations();
builder.AddAddressSpaceOptimizations();
}
internal static extern unsafe int AcceptSecurityContext(
ref CredHandle credentialHandle,
[In] void *inContextPtr,
[In] SecBufferDesc *inputBuffer,
[In] ContextFlags inFlags,
[In] Endianness endianness,
ref CredHandle outContextPtr,
[In, Out] ref SecBufferDesc outputBuffer,
[In, Out] ref ContextFlags attributes,
out long timeStamp
);
/// <summary>
/// Populates the given transformation manager with the required
/// optimization transformations.
/// </summary>
/// <param name="builder">The transformation manager to populate.</param>
/// <param name="contextFlags">The context flags.</param>
/// <param name="level">The desired optimization level.</param>
/// <returns>The maximum number of iterations.</returns>
public static void AddOptimizations(
this Transformer.Builder builder,
ContextFlags contextFlags,
OptimizationLevel level)
{
if (level < OptimizationLevel.O0 || level > OptimizationLevel.O2)
{
throw new ArgumentOutOfRangeException(nameof(level));
}
OptimizationHandlers[(int)level](builder, contextFlags);
}
public void SpanContext_ToString()
{
var traceId = new TraceId(1, 2);
var spanId = new SpanId(3);
var parentId = new SpanId(4);
ContextFlags flags = (ContextFlags)3;
var sc = new SpanContext(traceId, spanId, parentId, null, flags);
Assert.Equal("10000000000000002:3:4:3", sc.ToString());
}
internal GeneratorArgs(
PTXBackend backend,
EntryPoint entryPoint,
PTXDebugInfoGenerator debugInfoGenerator,
ContextFlags contextFlags)
{
Backend = backend;
EntryPoint = entryPoint;
DebugInfoGenerator = debugInfoGenerator;
ContextFlags = contextFlags;
}
public static Context Create(ContextFlags contextFlags)
{
if (IntPtr.Size == 8)
{
return(new Context64(contextFlags));
}
else
{
return(new Context32(contextFlags));
}
}
internal static extern int AcceptSecurityContext_1(
ref SECURITY_HANDLE phCredential,
SECURITY_HANDLE phContext,
ref SecBufferDesc pInput,
ContextFlags fContextReq,
uint TargetDataRep,
out SECURITY_HANDLE phNewContext,
out SecBufferDesc pOutput,
out ContextFlags pfContextAttr, //managed ulong == 64 bits!!!
out SECURITY_INTEGER ptsTimeStamp
);
/// <summary>
/// Adds general backend optimizations.
/// </summary>
/// <param name="builder">The transformation manager to populate.</param>
/// <param name="acceleratorSpecializer">
/// An instance of an <see cref="AcceleratorSpecializer"/> class.
/// </param>
/// <param name="contextFlags">The context flags.</param>
/// <param name="level">The desired optimization level.</param>
public static void AddBackendOptimizations(
this Transformer.Builder builder,
AcceleratorSpecializer acceleratorSpecializer,
ContextFlags contextFlags,
OptimizationLevel level)
{
// Specialize accelerator properties and views
builder.Add(new LowerPointerViews());
builder.Add(acceleratorSpecializer);
// Perform an additional inlining pass to specialize small device-specific
// functions that could have been introduced
if (!contextFlags.HasFlags(ContextFlags.NoInlining))
{
builder.Add(new Inliner());
}
// Skip further optimizations in debug mode
if (level < OptimizationLevel.O1)
{
return;
}
// Use experimental address-space specializer in O2 only
if (level > OptimizationLevel.O1)
{
// Specialize all parameter address spaces
builder.Add(new InferKernelAddressSpaces(MemoryAddressSpace.Global));
}
// Lower all value structures that could have been created during the
// following passes:
// LowerPointerViews, AcceleratorSpecializer and AddressSpaceSpecializer
builder.Add(new LowerStructures());
// Apply DCE phase in release mode to remove all dead values that
// could be created in prior passes
builder.Add(new DeadCodeElimination());
// Infer all specialized address spaces
if (level > OptimizationLevel.O1)
{
builder.Add(new InferLocalAddressSpaces());
}
else
{
builder.Add(new InferAddressSpaces());
}
// Final cleanup phases to improve performance
builder.Add(new CleanupBlocks());
builder.Add(new SimplifyControlFlow());
}
/// <summary>
/// Constructs a new ILGPU main context
/// </summary>
/// <param name="optimizationLevel">The optimization level.</param>
/// <param name="flags">The context flags.</param>
public Context(ContextFlags flags, OptimizationLevel optimizationLevel)
{
// Enable debug information automatically when a debugger is attached
if (Debugger.IsAttached)
{
flags |= DefaultDebug;
}
InstanceId = InstanceId.CreateNew();
OptimizationLevel = optimizationLevel;
Flags = flags.Prepare();
TargetPlatform = Backend.RuntimePlatform;
RuntimeSystem = new RuntimeSystem();
// Initialize enhanced PTX backend feature flags
if (optimizationLevel > OptimizationLevel.O1 &&
!Flags.HasFlags(ContextFlags.DefaultPTXBackendFeatures))
{
Flags |= ContextFlags.EnhancedPTXBackendFeatures;
}
// Initialize verifier
Verifier = flags.HasFlags(ContextFlags.EnableVerifier)
? Verifier.Instance
: Verifier.Empty;
// Initialize main contexts
TypeContext = new IRTypeContext(this);
IRContext = new IRContext(this);
// Create frontend
DebugInformationManager frontendDebugInformationManager =
HasFlags(ContextFlags.EnableDebugSymbols)
? DebugInformationManager
: null;
ILFrontend = HasFlags(ContextFlags.EnableParallelCodeGenerationInFrontend)
? new ILFrontend(this, frontendDebugInformationManager)
: new ILFrontend(this, frontendDebugInformationManager, 1);
// Create default IL backend
DefautltILBackend = new DefaultILBackend(this);
// Initialize default transformer
ContextTransformer = Optimizer.CreateTransformer(
OptimizationLevel,
TransformerConfiguration.Transformed,
Flags);
// Intrinsics
IntrinsicManager = new IntrinsicImplementationManager();
InitIntrinsics();
}
/// <summary>
/// Get the thread context.
/// </summary>
/// <param name="flags">Flags for context parts to get.</param>
/// <returns>An instance of an IContext object. Needs to be cast to correct type to access.</returns>
public IContext GetContext(ContextFlags flags)
{
// Really needs to support ARM as well.
if (Environment.Is64BitProcess)
{
return(GetAmd64Context(flags));
}
else
{
return(GetX86Context(flags));
}
}
private IContext GetX86Context(ContextFlags flags)
{
var context = new ContextX86();
context.ContextFlags = flags;
using (var buffer = context.ToBuffer())
{
NtSystemCalls.NtGetContextThread(Handle, buffer).ToNtException();
return(buffer.Result);
}
}
private NtResult <IContext> GetX86Context(ContextFlags flags, bool throw_on_error)
{
var context = new ContextX86
{
ContextFlags = flags
};
using (var buffer = context.ToBuffer())
{
return(NtSystemCalls.NtGetContextThread(Handle, buffer).CreateResult(throw_on_error, () => buffer.Result).Cast <IContext>());
}
}
/// <summary>
/// Populates the given transformation manager with the required
/// debug optimization transformations.
/// </summary>
/// <param name="builder">The transformation manager to populate.</param>
/// <param name="contextFlags">The context flags.</param>
public static void AddDebugOptimizations(
this Transformer.Builder builder,
ContextFlags contextFlags)
{
if (!contextFlags.HasFlags(ContextFlags.NoInlining))
{
builder.Add(new Inliner());
}
builder.Add(new SimplifyControlFlow());
builder.Add(new SSAConstruction());
builder.Add(new DeadCodeElimination());
}
internal static int AcceptSecurityContext(SSPIInterface SecModule, ref SafeFreeCredentials credential, ref SafeDeleteContext context, ContextFlags inFlags, Endianness datarep, SecurityBuffer inputBuffer, SecurityBuffer outputBuffer, ref ContextFlags outFlags)
{
if (Logging.On)
{
Logging.PrintInfo(Logging.Web, string.Concat(new object[] { "AcceptSecurityContext(credential = ", credential.ToString(), ", context = ", ValidationHelper.ToString(context), ", inFlags = ", inFlags, ")" }));
}
int num = SecModule.AcceptSecurityContext(ref credential, ref context, inputBuffer, inFlags, datarep, outputBuffer, ref outFlags);
if (Logging.On)
{
Logging.PrintInfo(Logging.Web, SR.GetString("net_log_sspi_security_context_input_buffer", new object[] { "AcceptSecurityContext", (inputBuffer == null) ? 0 : inputBuffer.size, outputBuffer.size, (SecurityStatus) num }));
}
return num;
}
internal static unsafe partial int InitializeSecurityContextW(
ref CredHandle credentialHandle,
void *inContextPtr,
byte *targetName,
ContextFlags inFlags,
int reservedI,
Endianness endianness,
SecBufferDesc *inputBuffer,
int reservedII,
ref CredHandle outContextPtr,
ref SecBufferDesc outputBuffer,
ref ContextFlags attributes,
out long timeStamp);
internal GeneratorArgs(
PTXBackend backend,
EntryPoint entryPoint,
ContextFlags contextFlags,
PTXDebugInfoGenerator debugInfoGenerator,
PointerAlignments pointerAlignments)
{
Backend = backend;
EntryPoint = entryPoint;
ContextFlags = contextFlags;
DebugInfoGenerator = debugInfoGenerator;
PointerAlignments = pointerAlignments;
}
internal NTAuthentication(bool isServer, string package, string spn, ContextFlags requestedContextFlags, System.Security.Authentication.ExtendedProtection.ChannelBinding channelBinding)
{
try
{
using (WindowsIdentity.Impersonate(IntPtr.Zero))
{
this.Initialize(isServer, package, SystemNetworkCredential.defaultCredential, spn, requestedContextFlags, channelBinding);
}
}
catch
{
throw;
}
}
//
private void Initialize(bool isServer, string package, NetworkCredential credential, string spn, ContextFlags requestedContextFlags, ChannelBinding channelBinding) {
GlobalLog.Print("NTAuthentication#" + ValidationHelper.HashString(this) + "::.ctor() package:" + ValidationHelper.ToString(package) + " spn:" + ValidationHelper.ToString(spn) + " flags :" + requestedContextFlags.ToString());
m_TokenSize = SSPIWrapper.GetVerifyPackageInfo(GlobalSSPI.SSPIAuth, package, true).MaxToken;
m_IsServer = isServer;
m_Spn = spn;
m_SecurityContext = null;
m_RequestedContextFlags = requestedContextFlags;
m_Package = package;
m_ChannelBinding = channelBinding;
GlobalLog.Print("Peer SPN-> '" + m_Spn + "'");
//
// check if we're using DefaultCredentials
//
if (credential is SystemNetworkCredential)
{
GlobalLog.Print("NTAuthentication#" + ValidationHelper.HashString(this) + "::.ctor(): using DefaultCredentials");
m_CredentialsHandle = SSPIWrapper.AcquireDefaultCredential(
GlobalSSPI.SSPIAuth,
package,
(m_IsServer? CredentialUse.Inbound: CredentialUse.Outbound));
m_UniqueUserId = "/S"; // save off for unique connection marking ONLY used by HTTP client
}
else if (ComNetOS.IsWin7orLater)
{
unsafe
{
SafeSspiAuthDataHandle authData = null;
try
{
SecurityStatus result = UnsafeNclNativeMethods.SspiHelper.SspiEncodeStringsAsAuthIdentity(
credential.InternalGetUserName(), credential.InternalGetDomain(),
credential.InternalGetPassword(), out authData);
if (result != SecurityStatus.OK)
{
if (Logging.On) Logging.PrintError(Logging.Web, SR.GetString(SR.net_log_operation_failed_with_error, "SspiEncodeStringsAsAuthIdentity()", String.Format(CultureInfo.CurrentCulture, "0x{0:X}", (int)result)));
throw new Win32Exception((int)result);
}
m_CredentialsHandle = SSPIWrapper.AcquireCredentialsHandle(GlobalSSPI.SSPIAuth,
package, (m_IsServer ? CredentialUse.Inbound : CredentialUse.Outbound), ref authData);
}
finally
{
if (authData != null)
{
authData.Close();
}
}
}
}
else
{
//
// we're not using DefaultCredentials, we need a
// AuthIdentity struct to contain credentials
// SECREVIEW:
// we'll save username/domain in temp strings, to avoid decrypting multiple times.
// password is only used once
//
string username = credential.InternalGetUserName();
string domain = credential.InternalGetDomain();
// ATTN:
// NetworkCredential class does not differentiate between null and "" but SSPI packages treat these cases differently
// For NTLM we want to keep "" for Wdigest.Dll we should use null.
AuthIdentity authIdentity = new AuthIdentity(username, credential.InternalGetPassword(), (object)package == (object)NegotiationInfoClass.WDigest && (domain == null || domain.Length == 0)? null: domain);
m_UniqueUserId = domain + "/" + username + "/U"; // save off for unique connection marking ONLY used by HTTP client
GlobalLog.Print("NTAuthentication#" + ValidationHelper.HashString(this) + "::.ctor(): using authIdentity:" + authIdentity.ToString());
m_CredentialsHandle = SSPIWrapper.AcquireCredentialsHandle(
GlobalSSPI.SSPIAuth,
package,
(m_IsServer? CredentialUse.Inbound: CredentialUse.Outbound),
ref authIdentity
);
}
}
internal InitializeCallbackContext(NTAuthentication thisPtr, bool isServer, string package, NetworkCredential credential, string spn, ContextFlags requestedContextFlags, ChannelBinding channelBinding)
{
this.thisPtr = thisPtr;
this.isServer = isServer;
this.package = package;
this.credential = credential;
this.spn = spn;
this.requestedContextFlags = requestedContextFlags;
this.channelBinding = channelBinding;
}
public int InitializeSecurityContext(SafeFreeCredentials credential, ref SafeDeleteContext context, string targetName, ContextFlags inFlags, Endianness endianness, SecurityBuffer[] inputBuffers, SecurityBuffer outputBuffer, ref ContextFlags outFlags) {
return SafeDeleteContext.InitializeSecurityContext(Library, ref credential, ref context, targetName, inFlags, endianness, null, inputBuffers, outputBuffer, ref outFlags);
}
private static void prepareContext (SqlConnection connection, string bingo_schema,
int id, ContextFlags flags)
{
BingoCore.setContext(id);
// Set basic paremeters for every request
// TODO: cache settings
BingoCore.setConfigInt("treat-x-as-pseudoatom",
BingoConfig.getInt(connection, bingo_schema, "treat-x-as-pseudoatom", id));
BingoCore.setConfigInt("ignore-stereocenter-errors",
BingoConfig.getInt(connection, bingo_schema, "ignore-stereocenter-errors", id));
BingoCore.setConfigInt("ignore-cistrans-errors",
BingoConfig.getInt(connection, bingo_schema, "ignore-cistrans-errors", id));
BingoCore.setConfigInt("allow-non-unique-dearomatization",
BingoConfig.getInt(connection, bingo_schema, "allow-non-unique-dearomatization", id));
BingoCore.setConfigInt("zero-unknown-aromatic-hydrogens",
BingoConfig.getInt(connection, bingo_schema, "zero-unknown-aromatic-hydrogens", id));
BingoCore.setConfigInt("stereochemistry-bidirectional-mode",
BingoConfig.getInt(connection, bingo_schema, "stereochemistry-bidirectional-mode", id));
BingoCore.setConfigInt("stereochemistry-detect-haworth-projection",
BingoConfig.getInt(connection, bingo_schema, "stereochemistry-detect-haworth-projection", id));
BingoCore.setConfigInt("ignore-closing-bond-direction-mismatch",
BingoConfig.getInt(connection, bingo_schema, "ignore-closing-bond-direction-mismatch", id));
BingoCore.setConfigInt("reject-invalid-structures",
BingoConfig.getInt(connection, bingo_schema, "reject-invalid-structures", id));
if ((flags & ContextFlags.NTHREADS) != 0)
{
BingoCore.setConfigInt("nthreads",
BingoConfig.getInt(connection, bingo_schema, "nthreads", id));
}
if ((flags & ContextFlags.TAU_RULES) != 0)
{
ArrayList rules = BingoConfig.getTautomerRules(connection, bingo_schema);
BingoCore.clearTautomerRules();
foreach (BingoConfig.TautomerRule rule in rules)
{
BingoCore.addTautomerRule(rule.n, rule.beg, rule.end);
}
BingoCore.tautomerRulesReady();
}
if ((flags & ContextFlags.FINGERPRINTS) != 0)
{
BingoCore.setConfigInt("FP_ORD_SIZE",
BingoConfig.getInt(connection, bingo_schema, "FP_ORD_SIZE", id));
BingoCore.setConfigInt("FP_ANY_SIZE",
BingoConfig.getInt(connection, bingo_schema, "FP_ANY_SIZE", id));
BingoCore.setConfigInt("FP_TAU_SIZE",
BingoConfig.getInt(connection, bingo_schema, "FP_TAU_SIZE", id));
BingoCore.setConfigInt("FP_SIM_SIZE",
BingoConfig.getInt(connection, bingo_schema, "FP_SIM_SIZE", id));
BingoCore.setConfigInt("SUB_SCREENING_MAX_BITS",
BingoConfig.getInt(connection, bingo_schema, "SUB_SCREENING_MAX_BITS", id));
BingoCore.setConfigInt("SIM_SCREENING_PASS_MARK",
BingoConfig.getInt(connection, bingo_schema, "SIM_SCREENING_PASS_MARK", id));
}
if ((flags & ContextFlags.CMF) != 0)
{
BingoCore.setConfigBin("cmf-dict",
BingoConfig.getBinary(connection, bingo_schema, "cmf-dict", id));
}
}
public static bool CryptAcquireContext(ref IntPtr hProv, string pszContainer, string pszProvider, CryptProvider prov, ContextFlags flags) => CryptAcquireContext(ref hProv, pszContainer, pszProvider, (uint) prov, (uint) flags);
private void ProcessThreadContext(int threadId, ContextFlags flag, ThreadContextHandler handler, bool isReadOnly = false)
{
if (handler == null)
throw new ArgumentNullException("handler");
var context = new CONTEXT { ContextFlags = flag };
if (SuspendThread(hThread) == 0xFFFFFFFF)
throw new Win32Exception();
if (!GetThreadContext(hThread, ref context))
throw new Win32Exception();
handler(ref context);
if (!isReadOnly)
{
if (!SetThreadContext(hThread, ref context))
throw new Win32Exception();
}
if (ResumeThread(hThread) == 0xFFFFFFFF)
throw new Win32Exception();
}
internal static int InitializeSecurityContext (SSPIInterface secModule, ref SafeFreeCredentials credentials, ref SafeDeleteContext safeContext, string targetName, ContextFlags inFlags, Endianness endianness, SecurityBuffer inputBuffer, SecurityBuffer outputBuffer, ref ContextFlags outFlags)
{
if (inputBuffer != null)
throw new InvalidOperationException ();
if (safeContext == null) {
secModule.Context.Initialize (secModule.EventSink);
safeContext = new SafeDeleteContext (secModule.Context);
}
return InitializeSecurityContext (secModule, credentials, ref safeContext, targetName, inFlags, endianness, null, outputBuffer, ref outFlags);
}
//-------------------------------------------------------------------
internal unsafe static int AcceptSecurityContext(
SecurDll dll,
ref SafeFreeCredentials inCredentials,
ref SafeDeleteContext refContext,
ContextFlags inFlags,
Endianness endianness,
SecurityBuffer inSecBuffer,
SecurityBuffer[] inSecBuffers,
SecurityBuffer outSecBuffer,
ref ContextFlags outFlags) {
#if TRAVE
GlobalLog.Enter("SafeDeleteContext::AcceptSecurityContex");
GlobalLog.Print(" DLL = " + dll);
GlobalLog.Print(" credential = " + inCredentials.ToString());
GlobalLog.Print(" refContext = " + ValidationHelper.ToString(refContext));
GlobalLog.Print(" inFlags = " + inFlags);
// GlobalLog.Print(" endianness = " + endianness);
// GlobalLog.Print(" inSecBuffer = " + SecurityBuffer.ToString(inSecBuffer));
//
if (inSecBuffers==null)
{
GlobalLog.Print(" inSecBuffers = (null)");
}
else
{
GlobalLog.Print(" inSecBuffers[] = length:" + inSecBuffers.Length);
// for (int index=0; index<inSecBuffers.Length; index++) { GlobalLog.Print(" inSecBuffers[" + index + "] = " + SecurityBuffer.ToString(inSecBuffers[index])); }
}
// GlobalLog.Print(" newContext = {ref} inContext");
// GlobalLog.Print(" outSecBuffer = " + SecurityBuffer.ToString(outSecBuffer));
// GlobalLog.Print(" outFlags = {ref} " + outFlags);
// GlobalLog.Print(" timestamp = null");
#endif
GlobalLog.Assert(outSecBuffer != null, "SafeDeleteContext::AcceptSecurityContext()|outSecBuffer != null");
GlobalLog.Assert(inSecBuffer == null || inSecBuffers == null, "SafeDeleteContext::AcceptSecurityContext()|inSecBuffer == null || inSecBuffers == null");
if (inCredentials == null)
{
throw new ArgumentNullException("inCredentials");
}
SecurityBufferDescriptor inSecurityBufferDescriptor = null;
if (inSecBuffer!=null)
{
inSecurityBufferDescriptor = new SecurityBufferDescriptor(1);
}
else if (inSecBuffers!=null)
{
inSecurityBufferDescriptor = new SecurityBufferDescriptor(inSecBuffers.Length);
}
SecurityBufferDescriptor outSecurityBufferDescriptor = new SecurityBufferDescriptor(1);
// actually this is returned in outFlags
bool isSspiAllocated = (inFlags & ContextFlags.AllocateMemory) != 0 ? true : false;
int errorCode = -1;
SSPIHandle contextHandle = new SSPIHandle();
if (refContext != null)
contextHandle = refContext._handle;
// these are pinned user byte arrays passed along with SecurityBuffers
GCHandle[] pinnedInBytes = null;
GCHandle pinnedOutBytes = new GCHandle();
// optional output buffer that may need to be freed
SafeFreeContextBuffer outFreeContextBuffer = null;
try
{
pinnedOutBytes = GCHandle.Alloc(outSecBuffer.token, GCHandleType.Pinned);
SecurityBufferStruct[] inUnmanagedBuffer = new SecurityBufferStruct[inSecurityBufferDescriptor==null ? 1:inSecurityBufferDescriptor.Count];
fixed (void* inUnmanagedBufferPtr = inUnmanagedBuffer)
{
if (inSecurityBufferDescriptor!=null)
{
// Fix Descriptor pointer that points to unmanaged SecurityBuffers
inSecurityBufferDescriptor.UnmanagedPointer = inUnmanagedBufferPtr;
pinnedInBytes = new GCHandle[inSecurityBufferDescriptor.Count];
SecurityBuffer securityBuffer;
for (int index = 0; index < inSecurityBufferDescriptor.Count; ++index)
{
securityBuffer = inSecBuffer!=null ? inSecBuffer : inSecBuffers[index];
if (securityBuffer!=null)
{
// Copy the SecurityBuffer content into unmanaged place holder
inUnmanagedBuffer[index].count = securityBuffer.size;
inUnmanagedBuffer[index].type = securityBuffer.type;
// use the unmanaged token if it's not null; otherwise use the managed buffer
if (securityBuffer.unmanagedToken != null)
{
inUnmanagedBuffer[index].token = securityBuffer.unmanagedToken.DangerousGetHandle();
}
else if (securityBuffer.token == null || securityBuffer.token.Length == 0)
{
inUnmanagedBuffer[index].token = IntPtr.Zero;
}
else
{
pinnedInBytes[index] = GCHandle.Alloc(securityBuffer.token, GCHandleType.Pinned);
inUnmanagedBuffer[index].token = Marshal.UnsafeAddrOfPinnedArrayElement(securityBuffer.token, securityBuffer.offset);
}
#if TRAVE
GlobalLog.Print("SecBuffer: cbBuffer:" + securityBuffer.size + " BufferType:" + securityBuffer.type);
#endif
}
}
}
SecurityBufferStruct[] outUnmanagedBuffer = new SecurityBufferStruct[1];
fixed (void* outUnmanagedBufferPtr = outUnmanagedBuffer)
{
// Fix Descriptor pointer that points to unmanaged SecurityBuffers
outSecurityBufferDescriptor.UnmanagedPointer = outUnmanagedBufferPtr;
// Copy the SecurityBuffer content into unmanaged place holder
outUnmanagedBuffer[0].count = outSecBuffer.size;
outUnmanagedBuffer[0].type = outSecBuffer.type;
if (outSecBuffer.token == null || outSecBuffer.token.Length == 0)
outUnmanagedBuffer[0].token = IntPtr.Zero;
else
outUnmanagedBuffer[0].token = Marshal.UnsafeAddrOfPinnedArrayElement(outSecBuffer.token, outSecBuffer.offset);
if (isSspiAllocated)
outFreeContextBuffer = SafeFreeContextBuffer.CreateEmptyHandle(dll);
switch (dll)
{
case SecurDll.SECURITY:
if (refContext == null || refContext.IsInvalid)
refContext = new SafeDeleteContext_SECURITY();
errorCode = MustRunAcceptSecurityContext_SECURITY(
ref inCredentials,
contextHandle.IsZero? null: &contextHandle,
inSecurityBufferDescriptor,
inFlags,
endianness,
refContext,
outSecurityBufferDescriptor,
ref outFlags,
outFreeContextBuffer
);
break;
default: throw new ArgumentException(SR.GetString(SR.net_invalid_enum, "SecurDll"), "Dll");
}
GlobalLog.Print("SafeDeleteContext:AcceptSecurityContext Marshalling OUT buffer");
// Get unmanaged buffer with index 0 as the only one passed into PInvoke
outSecBuffer.size = outUnmanagedBuffer[0].count;
outSecBuffer.type = outUnmanagedBuffer[0].type;
if (outSecBuffer.size > 0)
{
outSecBuffer.token = new byte[outSecBuffer.size];
Marshal.Copy(outUnmanagedBuffer[0].token, outSecBuffer.token, 0, outSecBuffer.size);
}
else
{
outSecBuffer.token = null;
}
}
}
}
finally {
if (pinnedInBytes!=null)
{
for (int index=0; index<pinnedInBytes.Length; index++)
{
if (pinnedInBytes[index].IsAllocated)
pinnedInBytes[index].Free();
}
}
if (pinnedOutBytes.IsAllocated)
pinnedOutBytes.Free();
if (outFreeContextBuffer != null)
outFreeContextBuffer.Close();
}
GlobalLog.Leave("SafeDeleteContext::AcceptSecurityContex() unmanaged AcceptSecurityContex()", "errorCode:0x" + errorCode.ToString("x8") + " refContext:" + ValidationHelper.ToString(refContext));
return errorCode;
}
//
// After PINvoke call the method will fix the handleTemplate.handle with the returned value.
// The caller is responsible for creating a correct SafeFreeContextBuffer_XXX flavour or null can be passed if no handle is returned.
//
// Since it has a CER, this method can't have any references to imports from DLLs that may not exist on the system.
//
private static unsafe int MustRunAcceptSecurityContext_SECURITY(
ref SafeFreeCredentials inCredentials,
void* inContextPtr,
SecurityBufferDescriptor inputBuffer,
ContextFlags inFlags,
Endianness endianness,
SafeDeleteContext outContext,
SecurityBufferDescriptor outputBuffer,
ref ContextFlags outFlags,
SafeFreeContextBuffer handleTemplate)
{
int errorCode = (int) SecurityStatus.InvalidHandle;
bool b1 = false;
bool b2 = false;
// Run the body of this method as a non-interruptible block.
RuntimeHelpers.PrepareConstrainedRegions();
try
{
inCredentials.DangerousAddRef(ref b1);
outContext.DangerousAddRef(ref b2);
}
catch(Exception e)
{
if (b1)
{
inCredentials.DangerousRelease();
b1 = false;
}
if (b2)
{
outContext.DangerousRelease();
b2 = false;
}
if (!(e is ObjectDisposedException))
throw;
}
finally {
SSPIHandle credentialHandle = inCredentials._handle;
long timeStamp;
if (!b1)
{
// caller should retry
inCredentials = null;
}
else if (b1 && b2)
{
errorCode = UnsafeNclNativeMethods.SafeNetHandles_SECURITY.AcceptSecurityContext(
ref credentialHandle,
inContextPtr,
inputBuffer,
inFlags,
endianness,
ref outContext._handle,
outputBuffer,
ref outFlags,
out timeStamp);
//
// When a credential handle is first associated with the context we keep credential
// ref count bumped up to ensure ordered finalization.
// If the credential handle has been changed we de-ref the old one and associate the
// context with the new cred handle but only if the call was successful.
if (outContext._EffectiveCredential != inCredentials && (errorCode & 0x80000000) == 0)
{
// Disassociate the previous credential handle
if (outContext._EffectiveCredential != null)
outContext._EffectiveCredential.DangerousRelease();
outContext._EffectiveCredential = inCredentials;
}
else
{
inCredentials.DangerousRelease();
}
outContext.DangerousRelease();
// The idea is that SSPI has allocated a block and filled up outUnmanagedBuffer+8 slot with the pointer.
if (handleTemplate != null)
{
handleTemplate.Set(((SecurityBufferStruct*)outputBuffer.UnmanagedPointer)->token); //ATTN: on 64 BIT that is still +8 cause of 2* c++ unsigned long == 8 bytes
if (handleTemplate.IsInvalid)
{
handleTemplate.SetHandleAsInvalid();
}
}
}
if (inContextPtr == null && (errorCode & 0x80000000) != 0)
{
// an error on the first call, need to set the out handle to invalid value
outContext._handle.SetToInvalid();
}
}
return errorCode;
}
extern static bool CryptAcquireContext(
[Out]out KeyContainerHandle phProv,
string pszContainer,
string pszProvider,
ProviderType dwProvType,
ContextFlags dwFlags);
internal static unsafe int AcceptSecurityContext(SecurDll dll, ref SafeFreeCredentials inCredentials, ref SafeDeleteContext refContext, ContextFlags inFlags, Endianness endianness, SecurityBuffer inSecBuffer, SecurityBuffer[] inSecBuffers, SecurityBuffer outSecBuffer, ref ContextFlags outFlags)
{
if (inCredentials == null)
{
throw new ArgumentNullException("inCredentials");
}
SecurityBufferDescriptor inputBuffer = null;
if (inSecBuffer != null)
{
inputBuffer = new SecurityBufferDescriptor(1);
}
else if (inSecBuffers != null)
{
inputBuffer = new SecurityBufferDescriptor(inSecBuffers.Length);
}
SecurityBufferDescriptor outputBuffer = new SecurityBufferDescriptor(1);
bool flag = (inFlags & ContextFlags.AllocateMemory) != ContextFlags.Zero;
int num = -1;
SSPIHandle handle = new SSPIHandle();
if (refContext != null)
{
handle = refContext._handle;
}
GCHandle[] handleArray = null;
GCHandle handle2 = new GCHandle();
SafeFreeContextBuffer handleTemplate = null;
try
{
handle2 = GCHandle.Alloc(outSecBuffer.token, GCHandleType.Pinned);
SecurityBufferStruct[] structArray = new SecurityBufferStruct[(inputBuffer == null) ? 1 : inputBuffer.Count];
try
{
SecurityBufferStruct[] structArray3;
if (((structArray3 = structArray) == null) || (structArray3.Length == 0))
{
ptrRef = null;
goto Label_00A5;
}
fixed (IntPtr* ptrRef = structArray3)
{
Label_00A5:
if (inputBuffer != null)
{
inputBuffer.UnmanagedPointer = (void*) ptrRef;
handleArray = new GCHandle[inputBuffer.Count];
for (int i = 0; i < inputBuffer.Count; i++)
{
SecurityBuffer buffer2 = (inSecBuffer != null) ? inSecBuffer : inSecBuffers[i];
if (buffer2 != null)
{
structArray[i].count = buffer2.size;
structArray[i].type = buffer2.type;
if (buffer2.unmanagedToken != null)
{
structArray[i].token = buffer2.unmanagedToken.DangerousGetHandle();
}
else if ((buffer2.token == null) || (buffer2.token.Length == 0))
{
structArray[i].token = IntPtr.Zero;
}
else
{
handleArray[i] = GCHandle.Alloc(buffer2.token, GCHandleType.Pinned);
structArray[i].token = Marshal.UnsafeAddrOfPinnedArrayElement(buffer2.token, buffer2.offset);
}
}
}
}
SecurityBufferStruct[] structArray2 = new SecurityBufferStruct[1];
try
{
SecurityBufferStruct[] structArray4;
if (((structArray4 = structArray2) == null) || (structArray4.Length == 0))
{
ptrRef2 = null;
goto Label_01CB;
}
fixed (IntPtr* ptrRef2 = structArray4)
{
Label_01CB:
outputBuffer.UnmanagedPointer = (void*) ptrRef2;
structArray2[0].count = outSecBuffer.size;
structArray2[0].type = outSecBuffer.type;
if ((outSecBuffer.token == null) || (outSecBuffer.token.Length == 0))
{
structArray2[0].token = IntPtr.Zero;
}
else
{
structArray2[0].token = Marshal.UnsafeAddrOfPinnedArrayElement(outSecBuffer.token, outSecBuffer.offset);
}
if (flag)
{
handleTemplate = SafeFreeContextBuffer.CreateEmptyHandle(dll);
}
switch (dll)
{
case SecurDll.SECURITY:
if ((refContext == null) || refContext.IsInvalid)
{
refContext = new SafeDeleteContext_SECURITY();
}
num = MustRunAcceptSecurityContext_SECURITY(ref inCredentials, handle.IsZero ? null : ((void*) &handle), inputBuffer, inFlags, endianness, refContext, outputBuffer, ref outFlags, handleTemplate);
break;
case SecurDll.SECUR32:
if ((refContext == null) || refContext.IsInvalid)
{
refContext = new SafeDeleteContext_SECUR32();
}
num = MustRunAcceptSecurityContext_SECUR32(ref inCredentials, handle.IsZero ? null : ((void*) &handle), inputBuffer, inFlags, endianness, refContext, outputBuffer, ref outFlags, handleTemplate);
break;
case SecurDll.SCHANNEL:
if ((refContext == null) || refContext.IsInvalid)
{
refContext = new SafeDeleteContext_SCHANNEL();
}
num = MustRunAcceptSecurityContext_SCHANNEL(ref inCredentials, handle.IsZero ? null : ((void*) &handle), inputBuffer, inFlags, endianness, refContext, outputBuffer, ref outFlags, handleTemplate);
break;
default:
throw new ArgumentException(SR.GetString("net_invalid_enum", new object[] { "SecurDll" }), "Dll");
}
outSecBuffer.size = structArray2[0].count;
outSecBuffer.type = structArray2[0].type;
if (outSecBuffer.size > 0)
{
outSecBuffer.token = new byte[outSecBuffer.size];
Marshal.Copy(structArray2[0].token, outSecBuffer.token, 0, outSecBuffer.size);
return num;
}
outSecBuffer.token = null;
return num;
}
}
finally
{
ptrRef2 = null;
}
return num;
}
}
finally
{
ptrRef = null;
}
}
finally
{
if (handleArray != null)
{
for (int j = 0; j < handleArray.Length; j++)
{
if (handleArray[j].IsAllocated)
{
handleArray[j].Free();
}
}
}
if (handle2.IsAllocated)
{
handle2.Free();
}
if (handleTemplate != null)
{
handleTemplate.Close();
}
}
return num;
}
public static int SetAttribute(ContextAttribute attr, ContextFlags value)
{
return SetAttribute(attr, (int)value);
}
internal NTAuthentication(bool isServer, string package, NetworkCredential credential, string spn, ContextFlags requestedContextFlags, System.Security.Authentication.ExtendedProtection.ChannelBinding channelBinding)
{
this.Initialize(isServer, package, credential, spn, requestedContextFlags, channelBinding);
}
public void GetThreadContext(ContextFlags flags, int contextBufferSize, out int contextSize, IntPtr contextBuffer)
{
uint uContextSize = 0;
m_sw.GetContext((uint)flags, (uint)contextBufferSize, out uContextSize, contextBuffer);
contextSize = (int)uContextSize;
}
public int AcceptSecurityContext(SafeFreeCredentials credential, ref SafeDeleteContext context, SecurityBuffer[] inputBuffers, ContextFlags inFlags, Endianness endianness, SecurityBuffer outputBuffer, ref ContextFlags outFlags) {
return SafeDeleteContext.AcceptSecurityContext(Library, ref credential, ref context, inFlags, endianness, null, inputBuffers, outputBuffer, ref outFlags);
}
internal static int AcceptSecurityContext(SSPIInterface SecModule, SafeFreeCredentials credential, ref SafeDeleteContext context, ContextFlags inFlags, Endianness datarep, SecurityBuffer[] inputBuffers, SecurityBuffer outputBuffer, ref ContextFlags outFlags)
{
if (Logging.On) Logging.PrintInfo(Logging.Web,
"AcceptSecurityContext(" +
"credential = " + credential.ToString() + ", " +
"context = " + ValidationHelper.ToString(context) + ", " +
"inFlags = " + inFlags + ")");
int errorCode = SecModule.AcceptSecurityContext(credential, ref context, inputBuffers, inFlags, datarep, outputBuffer, ref outFlags);
if (Logging.On) Logging.PrintInfo(Logging.Web, SR.GetString(SR.net_log_sspi_security_context_input_buffers, "AcceptSecurityContext", (inputBuffers == null ? 0 : inputBuffers.Length), outputBuffer.size, (SecurityStatus) errorCode));
return errorCode;
}
/*
* @safecontext is null on the first use, but it will become non-null for invocations
* where the connection is being re-negotiated.
*
*/
internal static int AcceptSecurityContext (SSPIInterface secModule, ref SafeFreeCredentials credentials, ref SafeDeleteContext safeContext, ContextFlags inFlags, Endianness endianness, SecurityBuffer inputBuffer, SecurityBuffer outputBuffer, ref ContextFlags outFlags)
{
if (endianness != Endianness.Native)
throw new NotSupportedException ();
if (safeContext == null) {
if (credentials == null || credentials.IsInvalid)
return (int)SecurityStatus.CredentialsNeeded;
secModule.Context.Initialize (secModule.EventSink);
safeContext = new SafeDeleteContext (secModule.Context);
}
SetCredentials (secModule, credentials);
var incoming = GetInputBuffer (inputBuffer);
IBufferOffsetSize outgoing;
var retval = (int)safeContext.Context.GenerateNextToken (incoming, out outgoing);
UpdateOutput (outgoing, outputBuffer);
return retval;
}
internal extern static bool CryptAcquireContext(
[Out]out KeyContainerHandle phProv,
[MarshalAs(UnmanagedType.LPWStr)] string pszContainer,
[MarshalAs(UnmanagedType.LPWStr)]string pszProvider,
ProviderType dwProvType,
ContextFlags dwFlags);
private static void saveContext (SqlConnection connection, string bingo_schema,
int id, ContextFlags flags)
{
BingoCore.setContext(id);
if ((flags & ContextFlags.CMF) != 0)
{
BingoConfig.setBinary(connection, bingo_schema, "cmf-dict", id,
BingoCore.getConfigBin("cmf-dict"));
}
}
//
// This overload does not attmept to impersonate because the caller either did it already or the original thread context is still preserved
//
internal NTAuthentication(bool isServer, string package, NetworkCredential credential, string spn, ContextFlags requestedContextFlags, ChannelBinding channelBinding) {
Initialize(isServer, package, credential, spn, requestedContextFlags, channelBinding);
}
private void Initialize(bool isServer, string package, NetworkCredential credential, string spn, ContextFlags requestedContextFlags, System.Security.Authentication.ExtendedProtection.ChannelBinding channelBinding)
{
this.m_TokenSize = SSPIWrapper.GetVerifyPackageInfo(GlobalSSPI.SSPIAuth, package, true).MaxToken;
this.m_IsServer = isServer;
this.m_Spn = spn;
this.m_SecurityContext = null;
this.m_RequestedContextFlags = requestedContextFlags;
this.m_Package = package;
this.m_ChannelBinding = channelBinding;
if (credential is SystemNetworkCredential)
{
this.m_CredentialsHandle = SSPIWrapper.AcquireDefaultCredential(GlobalSSPI.SSPIAuth, package, this.m_IsServer ? CredentialUse.Inbound : CredentialUse.Outbound);
this.m_UniqueUserId = "/S";
}
else
{
string userName = credential.InternalGetUserName();
string domain = credential.InternalGetDomain();
AuthIdentity authdata = new AuthIdentity(userName, credential.InternalGetPassword(), ((package == "WDigest") && ((domain == null) || (domain.Length == 0))) ? null : domain);
this.m_UniqueUserId = domain + "/" + userName + "/U";
this.m_CredentialsHandle = SSPIWrapper.AcquireCredentialsHandle(GlobalSSPI.SSPIAuth, package, this.m_IsServer ? CredentialUse.Inbound : CredentialUse.Outbound, ref authdata);
}
}
internal NTAuthentication(bool isServer, string package, string spn, ContextFlags requestedContextFlags, ChannelBinding channelBinding)
{
try
{
using (WindowsIdentity.Impersonate(IntPtr.Zero))
{
Initialize(isServer, package, SystemNetworkCredential.defaultCredential, spn, requestedContextFlags, channelBinding);
}
}
catch
{
// Avoid exception filter attacks.
throw;
}
}
/// <summary>
/// Set return state of run-time
/// </summary>
/// <param name="val">true or false</param>
public void SetReturn(bool val)
{
if (val && IsContinue()) throw new ScriptException("Implementation: Implementation error, consult with developer");
if (val && IsBreak()) throw new ScriptException("Implementation: Implementation error, consult with developer");
if (val)
flags = flags | ContextFlags.Return;
else
flags = flags & ~ContextFlags.Return;
}
internal static unsafe int InitializeSecurityContext(SecurDll dll, ref SafeFreeCredentials inCredentials, ref SafeDeleteContext refContext, string targetName, ContextFlags inFlags, Endianness endianness, SecurityBuffer inSecBuffer, SecurityBuffer[] inSecBuffers, SecurityBuffer outSecBuffer, ref ContextFlags outFlags)
{
if (inCredentials == null)
{
throw new ArgumentNullException("inCredentials");
}
SecurityBufferDescriptor inputBuffer = null;
if (inSecBuffer != null)
{
inputBuffer = new SecurityBufferDescriptor(1);
}
else if (inSecBuffers != null)
{
inputBuffer = new SecurityBufferDescriptor(inSecBuffers.Length);
}
SecurityBufferDescriptor outputBuffer = new SecurityBufferDescriptor(1);
bool flag = (inFlags & ContextFlags.AllocateMemory) != ContextFlags.Zero;
int num = -1;
SSPIHandle handle = new SSPIHandle();
if (refContext != null)
{
handle = refContext._handle;
}
GCHandle[] handleArray = null;
GCHandle handle2 = new GCHandle();
SafeFreeContextBuffer handleTemplate = null;
try
{
handle2 = GCHandle.Alloc(outSecBuffer.token, GCHandleType.Pinned);
SecurityBufferStruct[] structArray = new SecurityBufferStruct[(inputBuffer == null) ? 1 : inputBuffer.Count];
try
{
SecurityBufferStruct[] structArray3;
if (((structArray3 = structArray) == null) || (structArray3.Length == 0))
{
ptrRef = null;
goto Label_00A6;
}
fixed (IntPtr* ptrRef = structArray3)
{
Label_00A6:
if (inputBuffer != null)
{
inputBuffer.UnmanagedPointer = (void*) ptrRef;
handleArray = new GCHandle[inputBuffer.Count];
for (int i = 0; i < inputBuffer.Count; i++)
{
SecurityBuffer buffer2 = (inSecBuffer != null) ? inSecBuffer : inSecBuffers[i];
if (buffer2 != null)
{
structArray[i].count = buffer2.size;
structArray[i].type = buffer2.type;
if (buffer2.unmanagedToken != null)
{
structArray[i].token = buffer2.unmanagedToken.DangerousGetHandle();
}
else if ((buffer2.token == null) || (buffer2.token.Length == 0))
{
structArray[i].token = IntPtr.Zero;
}
else
{
handleArray[i] = GCHandle.Alloc(buffer2.token, GCHandleType.Pinned);
structArray[i].token = Marshal.UnsafeAddrOfPinnedArrayElement(buffer2.token, buffer2.offset);
}
}
}
}
SecurityBufferStruct[] structArray2 = new SecurityBufferStruct[1];
try
{
SecurityBufferStruct[] structArray4;
if (((structArray4 = structArray2) == null) || (structArray4.Length == 0))
{
ptrRef2 = null;
goto Label_01CC;
}
fixed (IntPtr* ptrRef2 = structArray4)
{
ref byte pinned numRef;
ref byte pinned numRef2;
Label_01CC:
outputBuffer.UnmanagedPointer = (void*) ptrRef2;
structArray2[0].count = outSecBuffer.size;
structArray2[0].type = outSecBuffer.type;
if ((outSecBuffer.token == null) || (outSecBuffer.token.Length == 0))
{
structArray2[0].token = IntPtr.Zero;
}
else
{
structArray2[0].token = Marshal.UnsafeAddrOfPinnedArrayElement(outSecBuffer.token, outSecBuffer.offset);
}
if (flag)
{
handleTemplate = SafeFreeContextBuffer.CreateEmptyHandle(dll);
}
switch (dll)
{
case SecurDll.SECURITY:
if ((refContext == null) || refContext.IsInvalid)
{
refContext = new SafeDeleteContext_SECURITY();
}
if ((targetName == null) || (targetName.Length == 0))
{
targetName = " ";
}
fixed (char* str = ((char*) targetName))
{
char* chPtr = str;
num = MustRunInitializeSecurityContext_SECURITY(ref inCredentials, handle.IsZero ? null : ((void*) &handle), (targetName == " ") ? null : ((byte*) chPtr), inFlags, endianness, inputBuffer, refContext, outputBuffer, ref outFlags, handleTemplate);
goto Label_044B;
}
break;
case SecurDll.SECUR32:
break;
case SecurDll.SCHANNEL:
goto Label_0381;
default:
goto Label_0423;
}
if ((refContext == null) || refContext.IsInvalid)
{
refContext = new SafeDeleteContext_SECUR32();
}
byte[] dummyBytes = SafeDeleteContext.dummyBytes;
if ((targetName != null) && (targetName.Length != 0))
{
dummyBytes = new byte[targetName.Length + 2];
Encoding.Default.GetBytes(targetName, 0, targetName.Length, dummyBytes, 0);
}
try
{
byte[] buffer5;
if (((buffer5 = dummyBytes) == null) || (buffer5.Length == 0))
{
numRef = null;
}
else
{
numRef = buffer5;
}
num = MustRunInitializeSecurityContext_SECUR32(ref inCredentials, handle.IsZero ? null : ((void*) &handle), (dummyBytes == SafeDeleteContext.dummyBytes) ? null : numRef, inFlags, endianness, inputBuffer, refContext, outputBuffer, ref outFlags, handleTemplate);
goto Label_044B;
}
finally
{
numRef = null;
}
Label_0381:
if ((refContext == null) || refContext.IsInvalid)
{
refContext = new SafeDeleteContext_SCHANNEL();
}
byte[] bytes = SafeDeleteContext.dummyBytes;
if ((targetName != null) && (targetName.Length != 0))
{
bytes = new byte[targetName.Length + 2];
Encoding.Default.GetBytes(targetName, 0, targetName.Length, bytes, 0);
}
try
{
byte[] buffer6;
if (((buffer6 = bytes) == null) || (buffer6.Length == 0))
{
numRef2 = null;
}
else
{
numRef2 = buffer6;
}
num = MustRunInitializeSecurityContext_SCHANNEL(ref inCredentials, handle.IsZero ? null : ((void*) &handle), (bytes == SafeDeleteContext.dummyBytes) ? null : numRef2, inFlags, endianness, inputBuffer, refContext, outputBuffer, ref outFlags, handleTemplate);
goto Label_044B;
}
finally
{
numRef2 = null;
}
Label_0423:;
throw new ArgumentException(SR.GetString("net_invalid_enum", new object[] { "SecurDll" }), "Dll");
Label_044B:
outSecBuffer.size = structArray2[0].count;
outSecBuffer.type = structArray2[0].type;
if (outSecBuffer.size > 0)
{
outSecBuffer.token = new byte[outSecBuffer.size];
Marshal.Copy(structArray2[0].token, outSecBuffer.token, 0, outSecBuffer.size);
return num;
}
outSecBuffer.token = null;
return num;
}
}
finally
{
ptrRef2 = null;
}
return num;
}
}
internal static int InitializeSecurityContext (SSPIInterface secModule, SafeFreeCredentials credentials, ref SafeDeleteContext safeContext, string targetName, ContextFlags inFlags, Endianness endianness, SecurityBuffer[] inputBuffers, SecurityBuffer outputBuffer, ref ContextFlags outFlags)
{
if (endianness != Endianness.Native)
throw new NotSupportedException ();
SetCredentials (secModule, credentials);
SecurityBuffer inputBuffer = null;
if (inputBuffers != null) {
if (inputBuffers.Length != 2 || inputBuffers [1].type != BufferType.Empty)
throw new NotSupportedException ();
inputBuffer = inputBuffers [0];
}
var incoming = GetInputBuffer (inputBuffer);
IBufferOffsetSize outgoing = null;
var retval = (int)safeContext.Context.GenerateNextToken (incoming, out outgoing);
UpdateOutput (outgoing, outputBuffer);
return retval;
}
internal NTAuthentication(bool isServer, string package, NetworkCredential credential, string spn, ContextFlags requestedContextFlags, ContextAwareResult context, ChannelBinding channelBinding)
{
//
// check if we're using DefaultCredentials
//
if (credential is SystemNetworkCredential)
{
//
#if DEBUG
GlobalLog.Assert(context == null || context.IdentityRequested, "NTAuthentication#{0}::.ctor|Authentication required when it wasn't expected. (Maybe Credentials was changed on another thread?)", ValidationHelper.HashString(this));
#endif
WindowsIdentity w = context == null ? null : context.Identity;
try
{
IDisposable ctx = w == null ? null : w.Impersonate();
if (ctx != null)
{
using (ctx)
{
Initialize(isServer, package, credential, spn, requestedContextFlags, channelBinding);
}
}
else
{
ExecutionContext x = context == null ? null : context.ContextCopy;
if (x == null)
{
Initialize(isServer, package, credential, spn, requestedContextFlags, channelBinding);
}
else
{
ExecutionContext.Run(x, s_InitializeCallback, new InitializeCallbackContext(this, isServer, package, credential, spn, requestedContextFlags, channelBinding));
}
}
}
catch
{
// Prevent the impersonation from leaking to upstack exception filters.
throw;
}
}
else
{
Initialize(isServer, package, credential, spn, requestedContextFlags, channelBinding);
}
}