public static void CreateIssuedToken(Guid transactionId, string coordinationContextId, ProtocolVersion protocolVersion, out RequestSecurityTokenResponse issuedToken, out string sctId)
        {
            sctId = CoordinationContext.CreateNativeIdentifier(Guid.NewGuid());
            byte[] key = DeriveIssuedTokenKey(transactionId, sctId);
            DateTime utcNow = DateTime.UtcNow;
            SecurityContextSecurityToken token = new SecurityContextSecurityToken(new UniqueId(sctId), key, utcNow, utcNow + TimeSpan.FromDays(36500.0));
            BinarySecretSecurityToken token2 = new BinarySecretSecurityToken(key);
            SecurityStandardsManager standardsManager = CreateStandardsManager(protocolVersion);
            RequestSecurityTokenResponse response = new RequestSecurityTokenResponse(standardsManager) {
                TokenType = standardsManager.SecureConversationDriver.TokenTypeUri,
                RequestedUnattachedReference = SecurityContextSecurityTokenParameters.CreateKeyIdentifierClause(token, SecurityTokenReferenceStyle.External),
                RequestedAttachedReference = SecurityContextSecurityTokenParameters.CreateKeyIdentifierClause(token, SecurityTokenReferenceStyle.Internal),
                RequestedSecurityToken = token,
                RequestedProofToken = token2
            };
            DataContractSerializer serializer = IdentifierElementSerializer(protocolVersion);
            ProtocolVersionHelper.AssertProtocolVersion(protocolVersion, typeof(CoordinationServiceSecurity), "CreateIssuedToken");
            switch (protocolVersion)
            {
                case ProtocolVersion.Version10:
                    response.SetAppliesTo<IdentifierElement10>(new IdentifierElement10(coordinationContextId), serializer);
                    break;

                case ProtocolVersion.Version11:
                    response.SetAppliesTo<IdentifierElement11>(new IdentifierElement11(coordinationContextId), serializer);
                    break;
            }
            response.MakeReadOnly();
            if (DebugTrace.Verbose)
            {
                DebugTrace.Trace(TraceLevel.Verbose, "Created issued token with id {0} for transaction {1}", sctId, transactionId);
            }
            issuedToken = response;
        }
		public NpgsqlPasswordPacket(String password, ProtocolVersion protocolVersion)
		{
			NpgsqlEventLog.LogMethodEnter(LogLevel.Debug, CLASSNAME, CLASSNAME);

			this.password = password;
			this.protocolVersion = protocolVersion;
		}
 public static void AssertProtocolVersion(ProtocolVersion protocolVersion, Type type, string method)
 {
     if (!Enum.IsDefined(typeof(ProtocolVersion), protocolVersion))
     {
         DiagnosticUtility.FailFast(string.Concat(new object[] { "An invalid protocol version value was used in ", type, '.', method }));
     }
 }
 // The demand is not added now (in 4.5), to avoid a breaking change. To be considered in the next version.
 /*
 // We demand full trust because we call into CoordinationStrings.Version(..), which is defined in a non-APTCA assembly and does an Environment.FailFast 
 // if the argument is invalid. It's recommended to not let partially trusted callers to bring down the process.
 // WSATs are not supported in partial trust, so customers should not be broken by this demand.
 [PermissionSet(SecurityAction.Demand, Unrestricted = true)]
 */
 public WsatTransactionHeader(CoordinationContext context, ProtocolVersion protocolVersion)
 {
     this.context = context;
     CoordinationStrings coordinationStrings = CoordinationStrings.Version(protocolVersion);                        
     this.wsatHeaderElement = coordinationStrings.CoordinationContext;
     this.wsatNamespace = coordinationStrings.Namespace;
 }
		public override bool VerifyData(ProtocolVersion version, byte[] data, HashAlgorithm hashAlgorithm, CertificatePublicKey key, byte[] signature)
		{
			if (signature.Length == 0) {
				return true;
			}
			return false;
		}
예제 #6
0
        public NpgsqlStartupPacket(Int32 packet_size,
                                   ProtocolVersion protocol_version,
                                   String database_name,
                                   String user_name,
                                   String arguments,
                                   String unused,
                                   String optional_tty)
        {

            NpgsqlEventLog.LogMethodEnter(LogLevel.Debug, CLASSNAME, CLASSNAME);
            // Just copy the values.

            // [FIXME] Validate params? We are the only clients, so, hopefully, we
            // know what to send.

            this.packet_size = packet_size;
            this.protocol_version = protocol_version;

            this.database_name = database_name;
            this.user_name = user_name;
            this.arguments = arguments;
            this.unused = unused;
            this.optional_tty = optional_tty;

        }
예제 #7
0
 public InfoSource(GuidPrefix guidPrefix)
     : base(SubMessageKind.INFO_SRC)
 {
     this.protocolVersion = ProtocolVersion.PROTOCOLVERSION_2_1;
     this.vendorId = VendorId.VENDORID_UNKNOWN;
     this.guidPrefix = guidPrefix;
 }
예제 #8
0
 /// <summary>
 /// Creates a new <see cref="ConnectionParameters"/>.
 /// </summary>
 public ConnectionParameters()
 {
     m_protocolVersion = ProtocolVersion.M;
     m_configurationFileName = null;
     m_refreshConfigurationFileOnChange = false;
     m_deviceLabel = null;
 }
예제 #9
0
 public NpgsqlAsciiRow(NpgsqlRowDescription rowDesc, ProtocolVersion protocolVersion, byte[] inputBuffer, char[] chars)
         : base(rowDesc, protocolVersion)
 {
     NpgsqlEventLog.LogMethodEnter(LogLevel.Debug, CLASSNAME, CLASSNAME);
     _inputBuffer = inputBuffer;
     _chars = chars;
 }
예제 #10
0
        public static IFrameBuilder GetBuilderFor(ProtocolVersion protocolVersion)
        {
            if(protocolVersion == ProtocolVersion.Hybi10)
                return new Hybi10ControlFrameBuilder();

            return null;
        }
 public static CoordinationContext GetCoordinationContext(Message message, ProtocolVersion protocolVersion)
 {
     int num;
     CoordinationContext context;
     CoordinationStrings strings = CoordinationStrings.Version(protocolVersion);
     string coordinationContext = strings.CoordinationContext;
     string ns = strings.Namespace;
     try
     {
         num = message.Headers.FindHeader(coordinationContext, ns);
     }
     catch (MessageHeaderException exception)
     {
         DiagnosticUtility.ExceptionUtility.TraceHandledException(exception, TraceEventType.Warning);
         return null;
     }
     if (num < 0)
     {
         return null;
     }
     XmlDictionaryReader readerAtHeader = message.Headers.GetReaderAtHeader(num);
     using (readerAtHeader)
     {
         context = GetCoordinationContext(readerAtHeader, protocolVersion);
     }
     MessageHeaderInfo headerInfo = message.Headers[num];
     if (!message.Headers.UnderstoodHeaders.Contains(headerInfo))
     {
         message.Headers.UnderstoodHeaders.Add(headerInfo);
     }
     return context;
 }
예제 #12
0
		void parameterizedProgrammaticOPIdentifierTest(Identifier opIdentifier, ProtocolVersion version,
			Identifier claimedUrl, AuthenticationRequestMode requestMode,
			AuthenticationStatus expectedResult, bool provideStore) {

			var rp = TestSupport.CreateRelyingParty(provideStore ? TestSupport.RelyingPartyStore : null, null, null);

			var returnTo = TestSupport.GetFullUrl(TestSupport.ConsumerPage);
			var realm = new Realm(TestSupport.GetFullUrl(TestSupport.ConsumerPage).AbsoluteUri);
			var request = rp.CreateRequest(opIdentifier, realm, returnTo);
			request.Mode = requestMode;

			var rpResponse = TestSupport.CreateRelyingPartyResponseThroughProvider(request,
				opReq => {
					opReq.IsAuthenticated = expectedResult == AuthenticationStatus.Authenticated;
					if (opReq.IsAuthenticated.Value) {
						opReq.ClaimedIdentifier = claimedUrl;
					}
				});
			Assert.AreEqual(expectedResult, rpResponse.Status);
			if (rpResponse.Status == AuthenticationStatus.Authenticated) {
				Assert.AreEqual(claimedUrl, rpResponse.ClaimedIdentifier);
			} else if (rpResponse.Status == AuthenticationStatus.SetupRequired) {
				Assert.IsNull(rpResponse.ClaimedIdentifier);
				Assert.IsNull(rpResponse.FriendlyIdentifierForDisplay);
				Assert.IsNull(rpResponse.Exception);
				Assert.IsInstanceOfType(typeof(ISetupRequiredAuthenticationResponse), rpResponse);
				Assert.AreEqual(opIdentifier.ToString(), ((ISetupRequiredAuthenticationResponse)rpResponse).ClaimedOrProviderIdentifier.ToString());
			}
		}
		public override byte[] GetClientKeys(ProtocolVersion version, ProtocolVersion clientVersion, CertificatePublicKey publicKey)
		{
			if (!(publicKey.Algorithm is RSACryptoServiceProvider)) {
				throw new CryptographicException("RSA key exchange requires RSA public key");
			}
			return GetClientKeys(version, clientVersion, (RSACryptoServiceProvider)publicKey.Algorithm);
		}
 public InteropRegistrationBinding(Uri clientBaseAddress, bool acceptSupportingTokens, ProtocolVersion protocolVersion) : base(clientBaseAddress, protocolVersion)
 {
     if (acceptSupportingTokens)
     {
         this.supportingTokenBE = new Microsoft.Transactions.Wsat.Messaging.SupportingTokenBindingElement(protocolVersion);
     }
 }
 public static void AssertProtocolVersion11(ProtocolVersion protocolVersion, Type type, string method)
 {
     if (protocolVersion != ProtocolVersion.Version11)
     {
         DiagnosticUtility.FailFast(string.Concat(new object[] { "Must use the protocol version 1.1 to execute ", type, '.', method }));
     }
 }
예제 #16
0
        public static NpgsqlStartupPacket BuildStartupPacket(ProtocolVersion protocol_version, String database_name, String user_name,
                                                             NpgsqlConnectionStringBuilder  settings)
        {
            NpgsqlEventLog.LogMethodEnter(LogLevel.Debug, CLASSNAME, "BuildStartupPacket");

            if (protocol_version == ProtocolVersion.Version2)
            {
                return new NpgsqlStartupPacketV2(database_name,user_name, "", "", "");
            }
            else
            {
                Dictionary<String, String> parameters = new Dictionary<String, String>();

                parameters.Add("DateStyle", "ISO");
                parameters.Add("client_encoding", "UTF8");
                parameters.Add("extra_float_digits", "2");
                parameters.Add("lc_monetary", "C");

                if (!string.IsNullOrEmpty(settings.ApplicationName))
                {
                    parameters.Add("application_name", settings.ApplicationName);
                }

                if (!string.IsNullOrEmpty(settings.SearchPath))
                {
                    parameters.Add("search_path", settings.SearchPath);
                }

                return new NpgsqlStartupPacketV3(database_name,user_name,parameters);
            }
        }
        // The demand is not added now (in 4.5), to avoid a breaking change. To be considered in the next version.
        /*
        // We demand full trust because we call into CoordinationContext and CoordinationStrings, which are defined in a non-APTCA assembly. Also, CoordinationStrings.Version(..) 
        // does an Environment.FailFast if the argument is invalid. It's recommended to not let partially trusted callers to bring down the process.
        // WSATs are not supported in partial trust, so customers should not be broken by this demand.
        [PermissionSet(SecurityAction.Demand, Unrestricted = true)]
        */
        public static CoordinationContext GetCoordinationContext(Message message, ProtocolVersion protocolVersion)
        {
            CoordinationStrings coordinationStrings = CoordinationStrings.Version(protocolVersion);
            string locWsatHeaderElement = coordinationStrings.CoordinationContext;
            string locWsatNamespace = coordinationStrings.Namespace;
            
            int index;
            try
            {
                index = message.Headers.FindHeader(locWsatHeaderElement, locWsatNamespace);
            }
            catch (MessageHeaderException e)
            {
                DiagnosticUtility.TraceHandledException(e, TraceEventType.Warning);
                return null;
            }
            if (index < 0)
                return null;

            CoordinationContext context;
            XmlDictionaryReader reader = message.Headers.GetReaderAtHeader(index);
            using (reader)
            {
                context = GetCoordinationContext(reader, protocolVersion);
            }

            MessageHeaderInfo header = message.Headers[index];
            if (!message.Headers.UnderstoodHeaders.Contains(header))
            {
                message.Headers.UnderstoodHeaders.Add(header);
            }

            return context;
        }
		public override bool SupportsProtocolVersion(ProtocolVersion version)
		{
			if (version.IsUsingDatagrams) {
				return false;
			}
			return true;
		}
예제 #19
0
 public Receiver(Header header)
     : this()
 {
     sourceGuidPrefix = header.GuidPrefix;
     sourceVersion = header.Version;
     throw new KeyNotFoundException("See page 35, unicast and multicast initialization");
 }
예제 #20
0
        private static void AddVersionTests(IList testSuite, ProtocolVersion version)
        {
            string prefix = version.ToString()
                .Replace(" ", "")
                .Replace("\\", "")
                .Replace(".", "")
                + "_";

            /*
             * NOTE: Temporarily disabled automatic test runs because of problems getting a clean exit
             * of the DTLS server after a fatal alert. As of writing, manual runs show the correct
             * alerts being raised
             */

            //{
            //    TlsTestConfig c = CreateDtlsTestConfig(version);
            //    c.clientAuth = C.CLIENT_AUTH_INVALID_VERIFY;
            //    c.ExpectServerFatalAlert(AlertDescription.decrypt_error);

            //    testSuite.Add(new TestCaseData(c).SetName(prefix + "BadCertificateVerify"));
            //}

            //{
            //    TlsTestConfig c = CreateDtlsTestConfig(version);
            //    c.clientAuth = C.CLIENT_AUTH_INVALID_CERT;
            //    c.ExpectServerFatalAlert(AlertDescription.bad_certificate);

            //    testSuite.Add(new TestCaseData(c).SetName(prefix + "BadClientCertificate"));
            //}

            //{
            //    TlsTestConfig c = CreateDtlsTestConfig(version);
            //    c.clientAuth = C.CLIENT_AUTH_NONE;
            //    c.serverCertReq = C.SERVER_CERT_REQ_MANDATORY;
            //    c.ExpectServerFatalAlert(AlertDescription.handshake_failure);

            //    testSuite.Add(new TestCaseData(c).SetName(prefix + "BadMandatoryCertReqDeclined"));
            //}

            {
                TlsTestConfig c = CreateDtlsTestConfig(version);

                testSuite.Add(new TestCaseData(c).SetName(prefix + "GoodDefault"));
            }

            {
                TlsTestConfig c = CreateDtlsTestConfig(version);
                c.serverCertReq = C.SERVER_CERT_REQ_NONE;

                testSuite.Add(new TestCaseData(c).SetName(prefix + "GoodNoCertReq"));
            }

            {
                TlsTestConfig c = CreateDtlsTestConfig(version);
                c.clientAuth = C.CLIENT_AUTH_NONE;

                testSuite.Add(new TestCaseData(c).SetName(prefix + "GoodOptionalCertReqDeclined"));
            }
        }
예제 #21
0
 public Receiver()
 {
     sourceVersion = ProtocolVersion.PROTOCOLVERSION;
     vendorId = VendorId.VENDORID_UNKNOWN;
     sourceGuidPrefix = GuidPrefix.GUIDPREFIX_UNKNOWN;
     haveTimestamp = false;
     timestamp = Time.TIME_INVALID;
 }
		Uri getPositiveAssertion(ProtocolVersion version) {
			OpenIdRelyingParty rp = TestSupport.CreateRelyingParty(null);
			Identifier id = TestSupport.GetMockIdentifier(TestSupport.Scenarios.AutoApproval, version);
			var request = rp.CreateRequest(id, realm, returnTo);
			var provider = TestSupport.CreateProviderForRequest(request);
			var opRequest = provider.Request as DotNetOpenId.Provider.IAuthenticationRequest;
			opRequest.IsAuthenticated = true;
			return opRequest.Response.ExtractUrl();
		}
예제 #23
0
		void replayAttackPrevention(ProtocolVersion version) {
			ServiceEndpoint ep = getServiceEndpoint(TestSupport.Scenarios.AutoApproval, version);
			Token token = new Token(ep);

			INonceStore store = new ApplicationMemoryStore();
			string serializedToken = token.Serialize(store);
			Token.Deserialize(serializedToken, store);
			Token.Deserialize(serializedToken, store);
		}
예제 #24
0
 public Finished(ProtocolVersion ver, byte[] verifyData)
     : base(HandshakeType.Finished)
 {
     if (ver == ProtocolVersion.SSL30 && verifyData.Length != 36)
         throw new ArgumentException ();
     if (ver != ProtocolVersion.SSL30 && verifyData.Length != 12)
         throw new ArgumentException ();
     _verifyData = verifyData;
 }
예제 #25
0
 /// <summary>
 /// init
 /// </summary>
 public RequestPackage(int msgId, string sessionId, int actionId, int userId, ProtocolVersion ptcl = ProtocolVersion.Default)
 {
     MsgId = msgId;
     SessionId = sessionId;
     ProxySid = Guid.Empty;
     ActionId = actionId;
     UserId = userId;
     Ptcl = ptcl;
 }
예제 #26
0
 public Finished(ProtocolVersion ver, byte[] buffer, int offset, uint length)
     : base(HandshakeType.Finished)
 {
     if (ver == ProtocolVersion.SSL30)
         _verifyData = new byte[36];
     else
         _verifyData = new byte[12];
     Buffer.BlockCopy (buffer, offset, _verifyData, 0, _verifyData.Length);
 }
 public ServiceProviderDescription(OAuthEndPoint requestTokenEndPoint,
                                   OAuthEndPoint authorizationEndPoint, 
                                   OAuthEndPoint accessTokenEndPoint, 
                                   ProtocolVersion protocolVersion = ProtocolVersion.V10)
 {
     this.RequestTokenEndPoint   = requestTokenEndPoint;
     this.AuthorizationEndPoint  = authorizationEndPoint;
     this.AccessTokenEndPoint    = accessTokenEndPoint;
     this.ProtocolVersion        = protocolVersion;
 }
예제 #28
0
 public ServerHello(ProtocolVersion ver, byte[] random, byte[] sessionID, CipherSuite suite, CompressionMethod compression, Extension[] extensions)
     : base(HandshakeType.ServerHello)
 {
     _version = ver;
     _random = random;
     _sessionID = sessionID;
     _cipherSuite = suite;
     _compression = compression;
     _extensions = extensions;
 }
예제 #29
0
        public HandshakeRequest(string handshakeRequest)
        {
            var lines = handshakeRequest.Split(Environment.NewLine.ToCharArray());

            foreach (var line in lines.Where(l=>string.IsNullOrEmpty(l) == false))
            {
                if(line.StartsWith("GET"))
                {
                    Path = line.Replace("GET /", "").Replace("HTTP/1.1", "").Trim();
                    continue;
                }

                if (line.StartsWith("Sec-WebSocket-Version:"))
                {
                    Version = int.Parse(line.Split(':')[1]) <= 7 ? ProtocolVersion.Hixie76 : ProtocolVersion.Hybi10;
                    continue;
                }

                if (line.StartsWith("Sec-WebSocket-Key:"))
                {
                    Key = line.Split(':')[1].Trim();
                    continue;
                }

                if (line.StartsWith("Host:"))
                {
                    Host = line.Split(':')[1].Trim();
                    continue;
                }

                if (line.StartsWith("Upgrade:"))
                {
                    Upgrade = line.Split(':')[1].Trim();
                    continue;
                }

                if (line.StartsWith("Connection:"))
                {
                    Connection = line.Split(':')[1].Trim();
                    continue;
                }

                if (line.StartsWith("Sec-WebSocket-Origin:"))
                {
                    Origin = line.Replace("Sec-WebSocket-Origin:", "").Trim();
                    continue;
                }

                if (line.StartsWith("Sec-WebSocket-Extensions:"))
                {
                    Extensions = line.Split(':')[1].Trim();
                    continue;
                }
            }
        }
예제 #30
0
		static ServiceEndpoint getServiceEndpoint(TestSupport.Scenarios scenario, ProtocolVersion version) {
			Protocol protocol = Protocol.Lookup(version);
			ServiceEndpoint ep = ServiceEndpoint.CreateForClaimedIdentifier(
				TestSupport.GetIdentityUrl(scenario, version),
				TestSupport.GetDelegateUrl(scenario),
				TestSupport.GetFullUrl(TestSupport.ProviderPage),
				new[] { protocol.ClaimedIdentifierServiceTypeURI },
				10,
				10
				);
			return ep;
		}
예제 #31
0
 /// <summary>
 /// Determines if the protocol version is supported by this driver.
 /// </summary>
 public static bool IsSupported(this ProtocolVersion version)
 {
     return(version >= ProtocolVersion.V1 && version <= ProtocolVersion.V4);
 }
예제 #32
0
        /// <inheritdoc/>
        public NetworkPeer CreateConnectedNetworkPeer(Network network, string endpoint, ProtocolVersion myVersion = ProtocolVersion.PROTOCOL_VERSION, bool isRelay = true, CancellationToken cancellation = default(CancellationToken))
        {
            IPEndPoint ipEndPoint = Utils.ParseIpEndpoint(endpoint, network.DefaultPort);
            var        parameters = new NetworkPeerConnectionParameters()
            {
                ConnectCancellation = cancellation,
                IsRelay             = isRelay,
                Version             = myVersion,
                Services            = NetworkPeerServices.Nothing,
            };

            return(this.CreateConnectedNetworkPeer(network, ipEndPoint, parameters));
        }
예제 #33
0
        public override void NotifyServerVersion(ProtocolVersion serverVersion)
        {
            base.NotifyServerVersion(serverVersion);

            Console.WriteLine("Negotiated " + serverVersion);
        }
예제 #34
0
 /// <summary>
 /// Determines whether the protocol supports unset parameters.
 /// </summary>
 /// <param name="version"></param>
 /// <returns></returns>
 public static bool SupportsUnset(this ProtocolVersion version)
 {
     return(version >= ProtocolVersion.V4);
 }
예제 #35
0
 public static void ReadWrite(this IBitcoinSerializable serializable, Stream stream, bool serializing, ProtocolVersion protocolVersion = ProtocolVersion.PROTOCOL_VERSION)
 {
     serializable.ReadWrite(new BitcoinStream(stream, serializing)
     {
         ProtocolVersion = protocolVersion
     });
 }
예제 #36
0
 /// <summary>
 /// Determines whether the collection length is encoded using 32 bits.
 /// </summary>
 public static bool Uses4BytesCollectionLength(this ProtocolVersion version)
 {
     return(version >= ProtocolVersion.V3);
 }
        public override IEnumerable <MacroOpBase> ToMacroOps(ProtocolVersion version)
        {
            if (Mask.HasFlag(MaskFlags.SizeX))
            {
                yield return new DVEAndFlyKeyXSizeMacroOp()
                       {
                           Index = MixEffectIndex, KeyIndex = KeyerIndex, SizeX = SizeX
                       }
            }
            ;

            if (Mask.HasFlag(MaskFlags.SizeY))
            {
                yield return new DVEAndFlyKeyYSizeMacroOp()
                       {
                           Index = MixEffectIndex, KeyIndex = KeyerIndex, SizeY = SizeY
                       }
            }
            ;

            if (Mask.HasFlag(MaskFlags.PositionX))
            {
                yield return new DVEAndFlyKeyXPositionMacroOp()
                       {
                           Index = MixEffectIndex, KeyIndex = KeyerIndex, PositionX = PositionX
                       }
            }
            ;

            if (Mask.HasFlag(MaskFlags.PositionY))
            {
                yield return new DVEAndFlyKeyYPositionMacroOp()
                       {
                           Index = MixEffectIndex, KeyIndex = KeyerIndex, PositionY = PositionY
                       }
            }
            ;

            if (Mask.HasFlag(MaskFlags.Rotation))
            {
                yield return new DVEAndFlyKeyRotationMacroOp()
                       {
                           Index = MixEffectIndex, KeyIndex = KeyerIndex, Rotation = Rotation
                       }
            }
            ;

            if (Mask.HasFlag(MaskFlags.BorderEnabled))
            {
                yield return new DVEKeyBorderEnableMacroOp()
                       {
                           Index = MixEffectIndex, KeyIndex = KeyerIndex, Enable = BorderEnabled
                       }
            }
            ;

            if (Mask.HasFlag(MaskFlags.BorderShadowEnabled))
            {
                yield return new DVEKeyShadowEnableMacroOp()
                       {
                           Index = MixEffectIndex, KeyIndex = KeyerIndex, Enable = BorderShadowEnabled
                       }
            }
            ;

            if (Mask.HasFlag(MaskFlags.BorderBevel))
            {
                yield return new DVEKeyBorderBevelMacroOp {
                           Index = MixEffectIndex, KeyIndex = KeyerIndex, Bevel = BorderBevel
                }
            }
            ;

            if (Mask.HasFlag(MaskFlags.BorderOuterWidth))
            {
                yield return new DVEKeyBorderOuterWidthMacroOp {
                           Index = MixEffectIndex, KeyIndex = KeyerIndex, OuterWidth = BorderOuterWidth
                }
            }
            ;

            if (Mask.HasFlag(MaskFlags.BorderInnerWidth))
            {
                yield return new DVEKeyBorderInnerWidthMacroOp {
                           Index = MixEffectIndex, KeyIndex = KeyerIndex, InnerWidth = BorderInnerWidth
                }
            }
            ;

            if (Mask.HasFlag(MaskFlags.BorderOuterSoftness))
            {
                yield return new DVEKeyBorderOuterSoftnessMacroOp {
                           Index = MixEffectIndex, KeyIndex = KeyerIndex, OuterSoftness = BorderOuterSoftness
                }
            }
            ;

            if (Mask.HasFlag(MaskFlags.BorderInnerSoftness))
            {
                yield return new DVEKeyBorderInnerSoftnessMacroOp {
                           Index = MixEffectIndex, KeyIndex = KeyerIndex, InnerSoftness = BorderInnerSoftness
                }
            }
            ;

            if (Mask.HasFlag(MaskFlags.BorderBevelSoftness))
            {
                yield return new DVEKeyBorderBevelSoftnessMacroOp {
                           Index = MixEffectIndex, KeyIndex = KeyerIndex, BevelSoftness = BorderBevelSoftness
                }
            }
            ;

            if (Mask.HasFlag(MaskFlags.BorderBevelPosition))
            {
                yield return new DVEKeyBorderBevelPositionMacroOp {
                           Index = MixEffectIndex, KeyIndex = KeyerIndex, BevelPosition = BorderBevelPosition
                }
            }
            ;

            if (Mask.HasFlag(MaskFlags.BorderOpacity))
            {
                yield return new DVEKeyBorderOpacityMacroOp {
                           Index = MixEffectIndex, KeyIndex = KeyerIndex, Opacity = BorderOpacity
                }
            }
            ;

            if (Mask.HasFlag(MaskFlags.BorderHue))
            {
                yield return new DVEKeyBorderHueMacroOp {
                           Index = MixEffectIndex, KeyIndex = KeyerIndex, Hue = BorderHue
                }
            }
            ;

            if (Mask.HasFlag(MaskFlags.BorderSaturation))
            {
                yield return new DVEKeyBorderSaturationMacroOp {
                           Index = MixEffectIndex, KeyIndex = KeyerIndex, Saturation = BorderSaturation
                }
            }
            ;

            if (Mask.HasFlag(MaskFlags.BorderLuma))
            {
                yield return new DVEKeyBorderLuminescenceMacroOp {
                           Index = MixEffectIndex, KeyIndex = KeyerIndex, Luma = BorderLuma
                }
            }
            ;

            if (Mask.HasFlag(MaskFlags.LightSourceDirection))
            {
                yield return new DVEKeyShadowDirectionMacroOp {
                           Index = MixEffectIndex, KeyIndex = KeyerIndex, Direction = LightSourceDirection
                }
            }
            ;

            if (Mask.HasFlag(MaskFlags.LightSourceAltitude))
            {
                yield return new DVEKeyShadowAltitudeMacroOp {
                           Index = MixEffectIndex, KeyIndex = KeyerIndex, Altitude = LightSourceAltitude
                }
            }
            ;

            if (Mask.HasFlag(MaskFlags.MaskEnabled))
            {
                yield return new DVEKeyMaskEnableMacroOp()
                       {
                           Index = MixEffectIndex, KeyIndex = KeyerIndex, Enable = MaskEnabled
                       }
            }
            ;

            if (Mask.HasFlag(MaskFlags.MaskTop))
            {
                yield return new DVEKeyMaskTopMacroOp()
                       {
                           Index = MixEffectIndex, KeyIndex = KeyerIndex, Top = MaskTop
                       }
            }
            ;

            if (Mask.HasFlag(MaskFlags.MaskBottom))
            {
                yield return new DVEKeyMaskBottomMacroOp()
                       {
                           Index = MixEffectIndex, KeyIndex = KeyerIndex, Bottom = MaskBottom
                       }
            }
            ;

            if (Mask.HasFlag(MaskFlags.MaskLeft))
            {
                yield return new DVEKeyMaskLeftMacroOp()
                       {
                           Index = MixEffectIndex, KeyIndex = KeyerIndex, Left = MaskLeft
                       }
            }
            ;

            if (Mask.HasFlag(MaskFlags.MaskRight))
            {
                yield return new DVEKeyMaskRightMacroOp()
                       {
                           Index = MixEffectIndex, KeyIndex = KeyerIndex, Right = MaskRight
                       }
            }
            ;

            if (Mask.HasFlag(MaskFlags.Rate))
            {
                yield return new DVEAndFlyKeyRateMacroOp {
                           Index = MixEffectIndex, KeyIndex = KeyerIndex, Rate = Rate
                }
            }
            ;
        }
    }
}
예제 #38
0
        public static VolatileEnlistmentInDoubtRecordSchema Instance(Guid enlistmentId, EndpointAddress replyTo, ProtocolVersion protocolVersion)
        {
            ProtocolVersionHelper.AssertProtocolVersion(protocolVersion, typeof(VolatileEnlistmentInDoubtRecordSchema), "Instance");
            switch (protocolVersion)
            {
            case ProtocolVersion.Version10:
                return(new VolatileEnlistmentInDoubtRecordSchema10(enlistmentId, replyTo));

            case ProtocolVersion.Version11:
                return(new VolatileEnlistmentInDoubtRecordSchema11(enlistmentId, replyTo));
            }
            return(null);
        }
 protected WsatTransactionFormatter(ProtocolVersion protocolVersion)
 {
     this.protocolVersion = protocolVersion;
 }
예제 #40
0
 public static int GetSerializedSize(this IBitcoinSerializable serializable, ProtocolVersion version = ProtocolVersion.PROTOCOL_VERSION)
 {
     return(GetSerializedSize(serializable, version, SerializationType.Disk));
 }
예제 #41
0
        public static void FromBytes(this IBitcoinSerializable serializable, byte[] bytes, ProtocolVersion version = ProtocolVersion.PROTOCOL_VERSION)
        {
            using (var ms = new MemoryStream(bytes))
            {
                var bitcoinStream = new BitcoinStream(ms, false)
                {
                    ProtocolVersion = version
                };

                serializable.ReadWrite(bitcoinStream);
            }
        }
예제 #42
0
 public static void ReadWrite(this IBitcoinSerializable serializable, byte[] bytes, ConsensusFactory consensusFactory, ProtocolVersion version = ProtocolVersion.PROTOCOL_VERSION)
 {
     using (var ms = new MemoryStream(bytes))
     {
         ReadWrite(serializable, ms, false, consensusFactory, version);
     }
 }
예제 #43
0
        public static void ReadWrite(this IBitcoinSerializable serializable, Stream stream, bool serializing, ConsensusFactory consensusFactory, ProtocolVersion protocolVersion = ProtocolVersion.PROTOCOL_VERSION)
        {
            if (consensusFactory == null)
            {
                throw new ArgumentException("{0} cannot be null", nameof(consensusFactory));
            }

            serializable.ReadWrite(new BitcoinStream(stream, serializing)
            {
                ProtocolVersion  = protocolVersion,
                ConsensusFactory = consensusFactory
            });
        }
예제 #44
0
        public static byte[] ToBytes(this IBitcoinSerializable serializable, ConsensusFactory consensusFactory, ProtocolVersion version = ProtocolVersion.PROTOCOL_VERSION)
        {
            if (consensusFactory == null)
            {
                throw new ArgumentException("{0} cannot be null", nameof(consensusFactory));
            }

            using (var ms = new MemoryStream())
            {
                var bms = new BitcoinStream(ms, true)
                {
                    ProtocolVersion  = version,
                    ConsensusFactory = consensusFactory
                };

                serializable.ReadWrite(bms);

                return(ToArrayEfficient(ms));
            }
        }
예제 #45
0
 /// <summary>
 /// Startup responses using protocol v4+ can be a SERVER_ERROR wrapping a ProtocolException,
 /// this method returns true when is possible to receive such error.
 /// </summary>
 public static bool CanStartupResponseErrorBeWrapped(this ProtocolVersion version)
 {
     return(version >= ProtocolVersion.V4);
 }
예제 #46
0
 public override bool SupportsProtocolVersion(ProtocolVersion version)
 {
     return(true);
 }
예제 #47
0
 /// <summary>
 /// Determines whether the QUERY, EXECUTE and BATCH flags are encoded using 32 bits.
 /// </summary>
 public static bool Uses4BytesQueryFlags(this ProtocolVersion version)
 {
     return(version >= ProtocolVersion.V5);
 }
예제 #48
0
 /// <summary>
 /// Determines whether the protocol supports up to 4 strings (ie: change_type, target, keyspace and table) in
 /// the schema change responses.
 /// </summary>
 public static bool SupportsSchemaChangeFullMetadata(this ProtocolVersion version)
 {
     return(version >= ProtocolVersion.V3);
 }
예제 #49
0
 /// <summary>
 /// Determines if streamIds are serialized used 2 bytes
 /// </summary>
 public static bool Uses2BytesStreamIds(this ProtocolVersion version)
 {
     return(version >= ProtocolVersion.V3);
 }
예제 #50
0
        /// <summary>
        /// Parse a Handshake ClientHello payload from wire format
        /// </summary>
        /// <returns>True if we successfully decode the ClientHello message. Otherwise false</returns>
        public static bool Parse(out ClientHello result, ByteSpan span)
        {
            result = new ClientHello();
            if (span.Length < MinSize)
            {
                return(false);
            }

            ProtocolVersion clientVersion = (ProtocolVersion)span.ReadBigEndian16();

            if (clientVersion != ProtocolVersion.DTLS1_2)
            {
                return(false);
            }
            span = span.Slice(2);

            result.Random = span.Slice(0, Dtls.Random.Size);
            span          = span.Slice(Dtls.Random.Size);

            ///NOTE(mendsley): We ignore session id
            byte sessionIdSize = span[0];

            if (span.Length < 1 + sessionIdSize)
            {
                return(false);
            }
            span = span.Slice(1 + sessionIdSize);

            byte cookieSize = span[0];

            if (span.Length < 1 + cookieSize)
            {
                return(false);
            }
            result.Cookie = span.Slice(1, cookieSize);
            span          = span.Slice(1 + cookieSize);

            ushort cipherSuiteSize = span.ReadBigEndian16();

            if (span.Length < 2 + cipherSuiteSize)
            {
                return(false);
            }
            else if (cipherSuiteSize % 2 != 0)
            {
                return(false);
            }
            result.CipherSuites = span.Slice(2, cipherSuiteSize);
            span = span.Slice(2 + cipherSuiteSize);

            int  compressionMethodsSize     = span[0];
            bool foundNullCompressionMethod = false;

            for (int ii = 0; ii != compressionMethodsSize; ++ii)
            {
                if (span[1 + ii] == (byte)CompressionMethod.Null)
                {
                    foundNullCompressionMethod = true;
                    break;
                }
            }
            span = span.Slice(1 + compressionMethodsSize);

            if (!foundNullCompressionMethod)
            {
                return(false);
            }

            // Parse extensions
            if (span.Length > 0)
            {
                ushort extensionsSize = span.ReadBigEndian16();
                span = span.Slice(2);
                if (span.Length != extensionsSize)
                {
                    return(false);
                }

                while (span.Length > 0)
                {
                    // Parse extension header
                    if (span.Length < 4)
                    {
                        return(false);
                    }

                    ExtensionType extensionType   = (ExtensionType)span.ReadBigEndian16(0);
                    ushort        extensionLength = span.ReadBigEndian16(2);
                    ByteSpan      extensionData   = span.Slice(4, extensionLength);
                    if (extensionData.Length < extensionLength)
                    {
                        return(false);
                    }

                    span = span.Slice(4 + extensionLength);
                    result.ParseExtension(extensionType, extensionData);
                }
            }

            return(true);
        }
예제 #51
0
 /// <summary>
 /// Determines whether the protocol supports BATCH requests.
 /// </summary>
 public static bool SupportsBatch(this ProtocolVersion version)
 {
     return(version >= ProtocolVersion.V2);
 }
 public PluggableProtocol(Guid protocolId, string name, ProtocolVersion protocolVersion)
 {
     this.protocolId      = protocolId;
     this.name            = name;
     this.protocolVersion = protocolVersion;
 }
예제 #53
0
 /// <summary>
 /// Determines whether the protocol supports timestamps parameters in BATCH, QUERY and EXECUTE requests.
 /// </summary>
 public static bool SupportsTimestamp(this ProtocolVersion version)
 {
     return(version >= ProtocolVersion.V3);
 }
 public GlobalAclOperationRequirement(List <string> windowsIdentities, List <string> x509Thumbprints, ProtocolVersion protocolVersion)
 {
     this.BuildSidDictionary((windowsIdentities != null) ? windowsIdentities : new List <string>());
     this.BuildThumbprintDictionary((x509Thumbprints != null) ? x509Thumbprints : new List <string>());
     this.protocolVersion = protocolVersion;
 }
        // see interface ConnectionReuseStrategy
        public virtual bool KeepAlive(HttpResponse response, HttpContext context)
        {
            Args.NotNull(response, "HTTP response");
            Args.NotNull(context, "HTTP context");
            // Check for a self-terminating entity. If the end of the entity will
            // be indicated by closing the connection, there is no keep-alive.
            ProtocolVersion ver = response.GetStatusLine().GetProtocolVersion();
            Header          teh = response.GetFirstHeader(HTTP.TransferEncoding);

            if (teh != null)
            {
                if (!Sharpen.Runtime.EqualsIgnoreCase(HTTP.ChunkCoding, teh.GetValue()))
                {
                    return(false);
                }
            }
            else
            {
                if (CanResponseHaveBody(response))
                {
                    Header[] clhs = response.GetHeaders(HTTP.ContentLen);
                    // Do not reuse if not properly content-length delimited
                    if (clhs.Length == 1)
                    {
                        Header clh = clhs[0];
                        try
                        {
                            int contentLen = System.Convert.ToInt32(clh.GetValue());
                            if (contentLen < 0)
                            {
                                return(false);
                            }
                        }
                        catch (FormatException)
                        {
                            return(false);
                        }
                    }
                    else
                    {
                        return(false);
                    }
                }
            }
            // Check for the "Connection" header. If that is absent, check for
            // the "Proxy-Connection" header. The latter is an unspecified and
            // broken but unfortunately common extension of HTTP.
            HeaderIterator hit = response.HeaderIterator(HTTP.ConnDirective);

            if (!hit.HasNext())
            {
                hit = response.HeaderIterator("Proxy-Connection");
            }
            // Experimental usage of the "Connection" header in HTTP/1.0 is
            // documented in RFC 2068, section 19.7.1. A token "keep-alive" is
            // used to indicate that the connection should be persistent.
            // Note that the final specification of HTTP/1.1 in RFC 2616 does not
            // include this information. Neither is the "Connection" header
            // mentioned in RFC 1945, which informally describes HTTP/1.0.
            //
            // RFC 2616 specifies "close" as the only connection token with a
            // specific meaning: it disables persistent connections.
            //
            // The "Proxy-Connection" header is not formally specified anywhere,
            // but is commonly used to carry one token, "close" or "keep-alive".
            // The "Connection" header, on the other hand, is defined as a
            // sequence of tokens, where each token is a header name, and the
            // token "close" has the above-mentioned additional meaning.
            //
            // To get through this mess, we treat the "Proxy-Connection" header
            // in exactly the same way as the "Connection" header, but only if
            // the latter is missing. We scan the sequence of tokens for both
            // "close" and "keep-alive". As "close" is specified by RFC 2068,
            // it takes precedence and indicates a non-persistent connection.
            // If there is no "close" but a "keep-alive", we take the hint.
            if (hit.HasNext())
            {
                try
                {
                    TokenIterator ti        = CreateTokenIterator(hit);
                    bool          keepalive = false;
                    while (ti.HasNext())
                    {
                        string token = ti.NextToken();
                        if (Sharpen.Runtime.EqualsIgnoreCase(HTTP.ConnClose, token))
                        {
                            return(false);
                        }
                        else
                        {
                            if (Sharpen.Runtime.EqualsIgnoreCase(HTTP.ConnKeepAlive, token))
                            {
                                // continue the loop, there may be a "close" afterwards
                                keepalive = true;
                            }
                        }
                    }
                    if (keepalive)
                    {
                        return(true);
                    }
                }
                catch (ParseException)
                {
                    // neither "close" nor "keep-alive", use default policy
                    // invalid connection header means no persistent connection
                    // we don't have logging in HttpCore, so the exception is lost
                    return(false);
                }
            }
            // default since HTTP/1.1 is persistent, before it was non-persistent
            return(!ver.LessEquals(HttpVersion.Http10));
        }
예제 #56
0
        /// <summary>
        /// Initializes a new instance of the object having a chain of block headers and a list of available nodes.
        /// </summary>
        /// <param name="chain">Chain of block headers.</param>
        /// <param name="nodes">Network peers of the node.</param>
        /// <param name="protocolVersion">Version of the protocol that the node supports.</param>
        /// <param name="loggerFactory">Factory to be used to create logger for the puller.</param>
        protected BlockPuller(ConcurrentChain chain, IReadOnlyNetworkPeerCollection nodes, ProtocolVersion protocolVersion, ILoggerFactory loggerFactory)
        {
            this.Chain                   = chain;
            this.Nodes                   = nodes;
            this.logger                  = loggerFactory.CreateLogger(this.GetType().FullName);
            this.downloadedBlocks        = new Dictionary <uint256, DownloadedBlock>();
            this.pendingInventoryVectors = new Queue <uint256>();
            this.assignedBlockTasks      = new Dictionary <uint256, BlockPullerBehavior>();
            this.peerQuality             = new QualityScore(QualityScoreHistoryLength, loggerFactory);

            // Set the default requirements.
            this.requirements = new NetworkPeerRequirement
            {
                MinVersion       = protocolVersion,
                RequiredServices = NetworkPeerServices.Network
            };
        }
예제 #57
0
 private Connection CreateConnection(ProtocolVersion protocolVersion, Configuration config)
 {
     Trace.TraceInformation("Creating test connection using protocol v{0}", protocolVersion);
     return(new Connection(new Serializer(protocolVersion), new IPEndPoint(new IPAddress(new byte[] { 127, 0, 0, 1 }), 9042), config));
 }
예제 #58
0
 /// <inheritdoc/>
 public NetworkPeerServer CreateNetworkPeerServer(Network network, ProtocolVersion version = ProtocolVersion.PROTOCOL_VERSION, int internalPort = -1)
 {
     return(new NetworkPeerServer(network, version, internalPort, this.dateTimeProvider, this.loggerFactory, this));
 }
예제 #59
0
        public static void FromBytes(this IBitcoinSerializable serializable, byte[] bytes, ConsensusFactory consensusFactory, ProtocolVersion version = ProtocolVersion.PROTOCOL_VERSION)
        {
            if (consensusFactory == null)
            {
                throw new ArgumentException("{0} cannot be null", nameof(consensusFactory));
            }

            using (var ms = new MemoryStream(bytes))
            {
                var bitcoinStream = new BitcoinStream(ms, false)
                {
                    ProtocolVersion  = version,
                    ConsensusFactory = consensusFactory
                };

                serializable.ReadWrite(bitcoinStream);
            }
        }
예제 #60
0
 public override IEnumerable <MacroOpBase> ToMacroOps(ProtocolVersion version)
 {
     yield return(new DownConvertModeMacroOp {
         DownConvertMode = DownConvertMode
     });
 }