public SubscribedForwardDestination(Growl.Daemon.Subscriber subscriber, int ttl)
     : this(subscriber.Name, true, subscriber.IPAddress, subscriber.Port, subscriber.Key.Password, KnownDestinationPlatformType.FromString(subscriber.PlatformName), ttl)
 {
     base.Key = subscriber.ID;
     this.hashAlgorithm = subscriber.Key.HashAlgorithm;
     this.encryptionAlgorithm = subscriber.Key.EncryptionAlgorithm;
 }
Exemple #2
0
 /// <summary>
 /// 接続先を詳細に指定してGrowlに接続する場合のコンストラクタ
 /// </summary>
 /// <param name="password">Growlへ接続をする際に使うパスワード</param>
 /// <param name="hostname">接続ホスト名 or 接続先のIPアドレス</param>
 /// <param name="port">接続するポート番号</param>
 /// <param name="encryptionAlgorithm">
 /// 通知メッセージの暗号化タイプを指定。
 /// デフォルトは「plaintext」
 /// </param>
 public GrowlManagerBase(string password, string hostname, int port, Cryptography.SymmetricAlgorithmType encryptionAlgorithm = Cryptography.SymmetricAlgorithmType.PlainText)
 {
     Connector = new GrowlConnector(password, hostname, port)
     {
         EncryptionAlgorithm = encryptionAlgorithm
     };
 }
Exemple #3
0
        /// <summary>
        /// Creates a new instance of the Key class.
        /// </summary>
        /// <param name="password">The user-supplied password to use as the basis for the key</param>
        /// <param name="hashAlgorithm">The <see cref="Cryptography.HashAlgorithmType"/> used when hashing values</param>
        /// <param name="encryptionAlgorithm">The <see cref="Cryptography.SymmetricAlgorithmType"/> used when encrypting values</param>
        protected Key(string password, Cryptography.HashAlgorithmType hashAlgorithm, Cryptography.SymmetricAlgorithmType encryptionAlgorithm)
        {
            if (!String.IsNullOrEmpty(password))
            {
                this.password            = password;
                this.hashAlgorithm       = hashAlgorithm;
                this.encryptionAlgorithm = encryptionAlgorithm;

                byte[] saltBytes = Cryptography.GenerateBytes(8);
                this.salt = Cryptography.HexEncode(saltBytes);

                byte[] passwordBytes = System.Text.Encoding.UTF8.GetBytes(password);
                byte[] keyBasis      = new byte[passwordBytes.Length + saltBytes.Length];
                Array.Copy(passwordBytes, 0, keyBasis, 0, passwordBytes.Length);
                Array.Copy(saltBytes, 0, keyBasis, passwordBytes.Length, saltBytes.Length);

                byte[] keyBytes = Cryptography.ComputeHash(keyBasis, hashAlgorithm);
                this.encryptionKey = keyBytes;

                byte[] keyHashBytes = Cryptography.ComputeHash(keyBytes, hashAlgorithm);
                this.keyHash = Cryptography.HexEncode(keyHashBytes);
            }
            else
            {
                InitializeEmptyKey();
            }
        }
Exemple #4
0
        /// <summary>
        /// Creates a new instance of the Key class.
        /// </summary>
        /// <param name="password">The user-supplied password to use as the basis for the key</param>
        /// <param name="hashAlgorithm">The <see cref="Cryptography.HashAlgorithmType"/> used when hashing values</param>
        /// <param name="encryptionAlgorithm">The <see cref="Cryptography.SymmetricAlgorithmType"/> used when encrypting values</param>
        protected Key(string password, Cryptography.HashAlgorithmType hashAlgorithm, Cryptography.SymmetricAlgorithmType encryptionAlgorithm)
        {
            if (!String.IsNullOrEmpty(password))
            {
                this.password = password;
                this.hashAlgorithm = hashAlgorithm;
                this.encryptionAlgorithm = encryptionAlgorithm;

                byte[] saltBytes = Cryptography.GenerateBytes(8);
                this.salt = Cryptography.HexEncode(saltBytes);

                byte[] passwordBytes = System.Text.Encoding.UTF8.GetBytes(password);
                byte[] keyBasis = new byte[passwordBytes.Length + saltBytes.Length];
                Array.Copy(passwordBytes, 0, keyBasis, 0, passwordBytes.Length);
                Array.Copy(saltBytes, 0, keyBasis, passwordBytes.Length, saltBytes.Length);

                byte[] keyBytes = Cryptography.ComputeHash(keyBasis, hashAlgorithm);
                this.encryptionKey = keyBytes;

                byte[] keyHashBytes = Cryptography.ComputeHash(keyBytes, hashAlgorithm);
                this.keyHash = Cryptography.HexEncode(keyHashBytes);
            }
            else
                InitializeEmptyKey();
        }
Exemple #5
0
 public SubscribedForwardDestination(Growl.Daemon.Subscriber subscriber, int ttl)
     : this(subscriber.Name, true, subscriber.IPAddress, subscriber.Port, subscriber.Key.Password, KnownDestinationPlatformType.FromString(subscriber.PlatformName), ttl)
 {
     base.Key                 = subscriber.ID;
     this.hashAlgorithm       = subscriber.Key.HashAlgorithm;
     this.encryptionAlgorithm = subscriber.Key.EncryptionAlgorithm;
 }
Exemple #6
0
        public static int Main(string[] args)
        {
            if (args == null || args.Length == 0)
            {
                Console.WriteLine("Invalid arguments. See /? for usage.");
                return(-1);
            }

            if (args[0] == "/?")
            {
                Console.WriteLine();
                string usage = global::growlnotify.Properties.Resources.usage;
                Console.WriteLine(usage);
                return(0);
            }

            // parse parameters
            Dictionary <string, Parameter> parameters = new Dictionary <string, Parameter>();

            try
            {
                foreach (string arg in args)
                {
                    Parameter p = GetParameterValue(arg);
                    parameters.Add(p.Argument, p);
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine("Bad arguments : " + ex.Message);
                return(-1);
            }

            // set default values
            string messageText     = "";
            string title           = "growlnotify";
            string id              = "";
            string coalescingid    = null;
            bool   sticky          = false;
            int    priorityInt     = 0;
            string iconFile        = null;
            string applicationName = "growlnotify";
            string appIconFile     = null;

            string[] notificationTypesToRegister = null;
            string   notificationType            = "General Notification";
            string   callbackUrl = null;
            string   protocol    = "GNTP";
            string   host        = "localhost";
            string   password    = null;

            Cryptography.SymmetricAlgorithmType encryptionAlgorithm = Cryptography.SymmetricAlgorithmType.PlainText;
            Cryptography.HashAlgorithmType      hashAlgorithm       = Cryptography.HashAlgorithmType.MD5;
            int port = GrowlConnector.TCP_PORT;

            // validate required parameters
            if (!parameters.ContainsKey("messagetext"))
            {
                Console.WriteLine("Missing 'messagetext' argument. See /? for usage");
                return(-1);
            }
            else
            {
                messageText = parameters["messagetext"].Value;
            }
            if (parameters.ContainsKey("/t"))
            {
                title = parameters["/t"].Value;
            }
            if (parameters.ContainsKey("/id"))
            {
                id = parameters["/id"].Value;
            }
            if (parameters.ContainsKey("/s"))
            {
                string s = parameters["/s"].Value.ToLower();
                if (s == "true")
                {
                    sticky = true;
                }
            }
            if (parameters.ContainsKey("/p"))
            {
                priorityInt = Convert.ToInt32(parameters["/p"].Value);
            }
            if (parameters.ContainsKey("/i"))
            {
                iconFile = parameters["/i"].Value;
                if (iconFile.StartsWith("."))
                {
                    string root = System.IO.Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location);
                    iconFile = System.IO.Path.Combine(root, iconFile);
                }
            }
            if (parameters.ContainsKey("/c"))
            {
                coalescingid = parameters["/c"].Value;
            }
            if (parameters.ContainsKey("/a"))
            {
                applicationName = parameters["/a"].Value;
            }
            if (parameters.ContainsKey("/ai"))
            {
                appIconFile = parameters["/ai"].Value;
                if (appIconFile.StartsWith("."))
                {
                    string root = System.IO.Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location);
                    appIconFile = System.IO.Path.Combine(root, iconFile);
                }
            }
            if (parameters.ContainsKey("/r"))
            {
                string[] parts = parameters["/r"].Value.Split(',');
                if (parts != null && parts.Length > 0)
                {
                    notificationTypesToRegister = new string[parts.Length];
                    for (int p = 0; p < parts.Length; p++)
                    {
                        string val = parts[p];
                        if (val.StartsWith("\""))
                        {
                            val = val.Substring(1, val.Length - 1);
                        }
                        if (val.EndsWith("\""))
                        {
                            val = val.Substring(0, val.Length - 1);
                        }
                        notificationTypesToRegister[p] = val;
                    }
                }
            }
            if (parameters.ContainsKey("/n"))
            {
                notificationType = parameters["/n"].Value;
            }
            if (parameters.ContainsKey("/cu"))
            {
                callbackUrl = parameters["/cu"].Value;
            }
            if (parameters.ContainsKey("/protocol"))
            {
                protocol = parameters["/protocol"].Value;
            }
            if (parameters.ContainsKey("/host"))
            {
                host = parameters["/host"].Value;
            }
            if (parameters.ContainsKey("/port"))
            {
                port = Convert.ToInt32(parameters["/port"].Value);
            }
            else
            {
                if (protocol == "UDP")
                {
                    port = 9887;
                }
            }
            if (parameters.ContainsKey("/pass"))
            {
                password = parameters["/pass"].Value;
            }
            if (parameters.ContainsKey("/enc"))
            {
                switch (parameters["/enc"].Value.ToUpper())
                {
                case "DES":
                    encryptionAlgorithm = Cryptography.SymmetricAlgorithmType.DES;
                    break;

                case "3DES":
                    encryptionAlgorithm = Cryptography.SymmetricAlgorithmType.TripleDES;
                    break;

                case "AES":
                    encryptionAlgorithm = Cryptography.SymmetricAlgorithmType.AES;
                    break;

                default:
                    encryptionAlgorithm = Cryptography.SymmetricAlgorithmType.PlainText;
                    break;
                }
            }
            if (parameters.ContainsKey("/hash"))
            {
                switch (parameters["/hash"].Value.ToUpper())
                {
                case "SHA1":
                    hashAlgorithm = Cryptography.HashAlgorithmType.SHA1;
                    break;

                case "SHA256":
                    hashAlgorithm = Cryptography.HashAlgorithmType.SHA256;
                    break;

                case "SHA512":
                    hashAlgorithm = Cryptography.HashAlgorithmType.SHA512;
                    break;

                default:
                    hashAlgorithm = Cryptography.HashAlgorithmType.MD5;
                    break;
                }
            }
            if (parameters.ContainsKey("/silent"))
            {
                string s = parameters["/silent"].Value.ToLower();
                if (s == "true")
                {
                    silent = true;
                }
            }

            // set up a waithandle so we can wait for responses
            ewh = new EventWaitHandle(false, EventResetMode.ManualReset);

            // set up growl connector
            growl = new GrowlConnector(password, host, port);
            growl.EncryptionAlgorithm = encryptionAlgorithm;
            growl.KeyHashAlgorithm    = hashAlgorithm;
            growl.OKResponse         += new GrowlConnector.ResponseEventHandler(growl_Response);
            growl.ErrorResponse      += new GrowlConnector.ResponseEventHandler(growl_Response);

            // do any registration first
            if (notificationTypesToRegister != null || applicationName == "growlnotify")
            {
                Growl.CoreLibrary.Resource appIcon = null;
                if (!String.IsNullOrEmpty(appIconFile))
                {
                    Uri uri = new Uri(appIconFile);
                    if (uri.IsFile && System.IO.File.Exists(uri.LocalPath))
                    {
                        appIcon = Growl.CoreLibrary.ImageConverter.ImageFromUrl(uri.LocalPath);
                    }
                    else
                    {
                        appIcon = appIconFile;
                    }
                }

                if (notificationTypesToRegister == null)
                {
                    notificationTypesToRegister = new string[] { "General Notification" };
                }
                NotificationType[] types = new NotificationType[notificationTypesToRegister.Length];
                for (int t = 0; t < types.Length; t++)
                {
                    string           nttr = notificationTypesToRegister[t];
                    NotificationType type = new NotificationType(nttr);
                    types[t] = type;
                }
                Application application = new Application(applicationName);
                application.Icon = appIcon;
                growl.Register(application, types);
                ewh.WaitOne();  // wait just to be sure the registration gets there first
            }

            // handle any callback information
            CallbackContext callback = null;

            if (!String.IsNullOrEmpty(callbackUrl))
            {
                callback = new CallbackContext(callbackUrl);
            }

            ewh.Reset();

            // handle icons (local icons will be sent as binary data, url-based icons will be sent as urls)
            Growl.CoreLibrary.Resource icon = null;
            if (!String.IsNullOrEmpty(iconFile))
            {
                Uri uri = new Uri(iconFile);
                if (uri.IsFile && System.IO.File.Exists(uri.LocalPath))
                {
                    icon = Growl.CoreLibrary.ImageConverter.ImageFromUrl(uri.LocalPath);
                }
                else
                {
                    icon = iconFile;
                }
            }

            // send the notification
            Priority     priority     = (Enum.IsDefined(typeof(Priority), priorityInt) ? (Priority)priorityInt : Priority.Normal);
            Notification notification = new Notification(applicationName, notificationType, id, title, messageText, icon, sticky, priority, coalescingid);

            growl.Notify(notification, callback);
            ewh.WaitOne();

            Console.WriteLine();
            return(r);
        }
Exemple #7
0
        /// <summary>

        /// Compares the provides keyHash and salt to the supplied password to see if they are a match.

        /// </summary>

        /// <param name="password">The password to compare to.</param>

        /// <param name="keyHash">The hex-encoded key hash</param>

        /// <param name="salt">The hex-encoded salt value</param>

        /// <param name="hashAlgorithm">The <see cref="Cryptography.HashAlgorithmType"/> used to generate the key hash</param>

        /// <param name="encryptionAlgorithm">The <see cref="Cryptography.SymmetricAlgorithmType"/> used by this key to do encryption/decryption</param>

        /// <param name="matchingKey">If a match is found, returns the matching <see cref="Key"/>;if no match is found, returns <c>null</c>.</param>

        /// <returns>

        /// <c>true</c> if the key hash and salt match the password;

        /// <c>false</c> otherwise

        /// </returns>

        public static bool Compare(string password, string keyHash, string salt, Cryptography.HashAlgorithmType hashAlgorithm, Cryptography.SymmetricAlgorithmType encryptionAlgorithm, out Key matchingKey)

        {
            matchingKey = null;

            if (!String.IsNullOrEmpty(password))

            {
                byte[] passwordBytes = System.Text.Encoding.UTF8.GetBytes(password);

                byte[] saltBytes = Cryptography.HexUnencode(salt);

                byte[] keyBasis = new byte[passwordBytes.Length + saltBytes.Length];

                Array.Copy(passwordBytes, 0, keyBasis, 0, passwordBytes.Length);

                Array.Copy(saltBytes, 0, keyBasis, passwordBytes.Length, saltBytes.Length);



                byte[] keyBytes = Cryptography.ComputeHash(keyBasis, hashAlgorithm);

                byte[] keyHashBytes = Cryptography.ComputeHash(keyBytes, hashAlgorithm);

                string actualKeyHash = Cryptography.HexEncode(keyHashBytes);



                if (keyHash == actualKeyHash)

                {
                    matchingKey = new Key();

                    matchingKey.password = password;

                    matchingKey.salt = salt;

                    matchingKey.keyHash = keyHash;

                    matchingKey.hashAlgorithm = hashAlgorithm;

                    matchingKey.encryptionKey = keyBytes;

                    matchingKey.encryptionAlgorithm = encryptionAlgorithm;

                    return(true);
                }
            }

            return(false);
        }
Exemple #8
0
        /// <summary>

        /// Generates a <see cref="Key"/> based on the supplied password and algorithms.

        /// </summary>

        /// <param name="password">The password to use as the basis for the key.</param>

        /// <param name="hashAlgorithm">The <see cref="Cryptography.HashAlgorithmType"/> used when hashing values</param>

        /// <param name="encryptionAlgorithm">The <see cref="Cryptography.SymmetricAlgorithmType"/> used when encrypting values</param>

        /// <returns><see cref="Key"/></returns>

        public static Key GenerateKey(string password, Cryptography.HashAlgorithmType hashAlgorithm, Cryptography.SymmetricAlgorithmType encryptionAlgorithm)

        {
            if (String.IsNullOrEmpty(password))
            {
                return(Key.None);
            }

            else
            {
                return(new Key(password, hashAlgorithm, encryptionAlgorithm));
            }
        }
        private void ProcessBuffer()

        {
            try

            {
                Data data = new Data(buffer.ToArray());

                string s = data.ToString();

                alreadyReceived.Append(s);



                if (tag == START_TAG)

                {
                    // start looking for GNTP header

                    tag = GNTP_IDENTIFIER_TAG;

                    ContinueProcessing();
                }



                else if (tag == GNTP_IDENTIFIER_TAG)

                {
                    string line = s;

                    Match match = ParseGNTPHeaderLine(line, this.passwordRequired);



                    if (match.Success)

                    {
                        this.version = match.Groups["Version"].Value;

                        if (version == MessageParser.GNTP_SUPPORTED_VERSION)

                        {
                            string d = match.Groups["Directive"].Value;

                            if (Enum.IsDefined(typeof(RequestType), d))

                            {
                                this.directive = (RequestType)Enum.Parse(typeof(RequestType), d);



                                // check for supported but not allowed requests

                                if (this.directive == RequestType.SUBSCRIBE && !this.allowSubscriptions)

                                {
                                    OnError(ErrorCode.NOT_AUTHORIZED, ErrorDescription.SUBSCRIPTIONS_NOT_ALLOWED);
                                }

                                else

                                {
                                    this.encryptionAlgorithm = Cryptography.GetEncryptionType(match.Groups["EncryptionAlgorithm"].Value);

                                    this.ivHex = (match.Groups["IV"] != null ? match.Groups["IV"].Value : null);

                                    if (!String.IsNullOrEmpty(this.ivHex))
                                    {
                                        this.iv = Cryptography.HexUnencode(this.ivHex);
                                    }

                                    string keyHash = match.Groups["KeyHash"].Value.ToUpper();



                                    bool authorized = false;

                                    // Any of the following criteria require a password:

                                    //    1. the request did not originate on the local machine or LAN

                                    //    2. the request came from the LAN, but LAN passwords are required

                                    //    2. it is a SUBSCRIBE request (all subscriptions require a password)

                                    //    3. the user's preferences require even local requests to supply a password

                                    // Additionally, even if a password is not required, it will be validated if the

                                    // sending appplication includes one

                                    string errorDescription = ErrorDescription.INVALID_KEY;

                                    if (this.passwordRequired || this.directive == RequestType.SUBSCRIBE || !String.IsNullOrEmpty(keyHash))

                                    {
                                        if (String.IsNullOrEmpty(keyHash))

                                        {
                                            errorDescription = ErrorDescription.MISSING_KEY;
                                        }

                                        else

                                        {
                                            string keyHashAlgorithmType = match.Groups["KeyHashAlgorithm"].Value;

                                            this.keyHashAlgorithm = Cryptography.GetKeyHashType(keyHashAlgorithmType);

                                            string salt = match.Groups["Salt"].Value.ToUpper();

                                            authorized = this.passwordManager.IsValid(keyHash, salt, this.keyHashAlgorithm, this.encryptionAlgorithm, out this.key);
                                        }
                                    }

                                    else

                                    {
                                        authorized = true;

                                        this.key = Key.None;
                                    }



                                    if (authorized)

                                    {
                                        if (this.encryptionAlgorithm == Cryptography.SymmetricAlgorithmType.PlainText)

                                        {
                                            tag = HEADER_TAG;

                                            ContinueProcessing();
                                        }

                                        else

                                        {
                                            tag = ENCRYPTED_HEADERS_TAG;

                                            ContinueProcessing();
                                        }
                                    }

                                    else

                                    {
                                        OnError(ErrorCode.NOT_AUTHORIZED, errorDescription);
                                    }
                                }
                            }

                            else

                            {
                                OnError(ErrorCode.INVALID_REQUEST, ErrorDescription.UNSUPPORTED_DIRECTIVE, d);
                            }
                        }

                        else

                        {
                            OnError(ErrorCode.UNKNOWN_PROTOCOL_VERSION, ErrorDescription.UNSUPPORTED_VERSION, version);
                        }
                    }

                    else

                    {
                        OnError(ErrorCode.UNKNOWN_PROTOCOL, ErrorDescription.MALFORMED_REQUEST);
                    }
                }



                else if (tag == HEADER_TAG)

                {
                    if (s == MessageParser.BLANK_LINE)

                    {
                        // if this is a REGISTER message, check Notifications-Count value

                        // to see how many notification sections to expect

                        if (this.directive == RequestType.REGISTER)

                        {
                            if (this.expectedNotifications > 0)

                            {
                                tag = NOTIFICATION_TYPE_TAG;

                                ContinueProcessing();
                            }

                            else

                            {
                                // a REGISTER request with no notifications is not valid

                                OnError(ErrorCode.INVALID_REQUEST, ErrorDescription.NO_NOTIFICATIONS_REGISTERED);
                            }
                        }

                        else

                        {
                            // otherwise, check the number of resource pointers we got and start reading those

                            this.pointersExpected = GetNumberOfPointers();

                            if (this.pointersExpected > 0)

                            {
                                this.pointersExpectedRemaining = this.pointersExpected;

                                this.currentPointer = 1;

                                tag = RESOURCE_HEADER_TAG;

                                ContinueProcessing();
                            }

                            else

                            {
                                OnMessageParsed();
                            }
                        }
                    }

                    else

                    {
                        Header header = Header.ParseHeader(s);

                        if (header != null)

                        {
                            bool addHeader = true;

                            if (header.Name == Header.APPLICATION_NAME)

                            {
                                this.applicationName = header.Value;
                            }

                            if (header.Name == Header.NOTIFICATIONS_COUNT)

                            {
                                this.expectedNotifications = Convert.ToInt32(header.Value);

                                this.expectedNotificationsRemaining = this.expectedNotifications;

                                this.currentNotification = 1;
                            }

                            if (header.Name == Header.NOTIFICATION_CALLBACK_CONTEXT)

                            {
                                this.callbackData = header.Value;
                            }

                            if (header.Name == Header.NOTIFICATION_CALLBACK_CONTEXT_TYPE)

                            {
                                this.callbackDataType = header.Value;
                            }

                            if (header.Name == Header.NOTIFICATION_CALLBACK_TARGET || header.Name == Header.NOTIFICATION_CALLBACK_CONTEXT_TARGET)   // left in for compatibility

                            {
                                this.callbackUrl = header.Value;
                            }

                            if (header.Name == Header.RECEIVED)

                            {
                                this.requestInfo.PreviousReceivedHeaders.Add(header);

                                addHeader = false;
                            }



                            if (addHeader)
                            {
                                this.headers.AddHeader(header);
                            }
                        }

                        tag = HEADER_TAG;

                        ContinueProcessing();
                    }
                }



                else if (tag == NOTIFICATION_TYPE_TAG)

                {
                    if (s == MessageParser.BLANK_LINE)

                    {
                        this.expectedNotificationsRemaining--;

                        if (this.expectedNotificationsRemaining > 0)

                        {
                            this.currentNotification++;

                            tag = NOTIFICATION_TYPE_TAG;

                            ContinueProcessing();
                        }

                        else

                        {
                            // otherwise, check the number of resource pointers we got and start reading those

                            this.pointersExpected = GetNumberOfPointers();

                            if (this.pointersExpected > 0)

                            {
                                this.pointersExpectedRemaining = this.pointersExpected;

                                this.currentPointer = 1;

                                tag = RESOURCE_HEADER_TAG;

                                ContinueProcessing();
                            }

                            else

                            {
                                OnMessageParsed();
                            }
                        }
                    }

                    else

                    {
                        if (this.notificationsToBeRegistered.Count < this.currentNotification)

                        {
                            this.notificationsToBeRegistered.Add(new HeaderCollection());
                        }



                        Header header = Header.ParseHeader(s);

                        this.notificationsToBeRegistered[this.currentNotification - 1].AddHeader(header);

                        tag = NOTIFICATION_TYPE_TAG;

                        ContinueProcessing();
                    }
                }



                else if (tag == RESOURCE_HEADER_TAG)

                {
                    if (s == MessageParser.BLANK_LINE)

                    {
                        // we should have found an Identifier header and Length header, or we are just starting a new section

                        Pointer p = this.pointers[this.currentPointer - 1];

                        if (p.Identifier != null && p.Length > 0)

                        {
                            // read #of bytes

                            int length = this.pointers[this.currentPointer - 1].Length;

                            tag = RESOURCE_TAG;

                            ContinueProcessing();
                        }

                        else

                        {
                            tag = RESOURCE_HEADER_TAG;

                            ContinueProcessing();
                        }
                    }

                    else

                    {
                        Header header = Header.ParseHeader(s);

                        // should be Identifer or Length

                        if (header != null)

                        {
                            bool validHeader = false;

                            if (header.Name == Header.RESOURCE_IDENTIFIER)

                            {
                                this.pointers[this.currentPointer - 1].Identifier = header.Value;

                                validHeader = true;
                            }

                            else if (header.Name == Header.RESOURCE_LENGTH)

                            {
                                this.pointers[this.currentPointer - 1].Length = Convert.ToInt32(header.Value);

                                validHeader = true;
                            }

                            else

                            {
                                OnError(ErrorCode.INVALID_REQUEST, ErrorDescription.UNRECOGNIZED_RESOURCE_HEADER, header.Name);
                            }



                            if (validHeader)

                            {
                                tag = RESOURCE_HEADER_TAG;

                                ContinueProcessing();
                            }
                        }

                        else

                        {
                            OnError(ErrorCode.INVALID_REQUEST, ErrorDescription.UNRECOGNIZED_RESOURCE_HEADER);
                        }
                    }
                }



                else if (tag == RESOURCE_TAG)

                {
                    // deal with data bytes

                    byte[] bytes = this.key.Decrypt(data.ByteArray, this.iv);



                    Pointer pointer = this.pointers[this.currentPointer - 1];

                    pointer.ByteArray = bytes;

                    BinaryData binaryData = new BinaryData(pointer.Identifier, pointer.ByteArray);

                    ResourceCache.Add(this.applicationName, binaryData);



                    this.pointersExpectedRemaining--;

                    if (this.pointersExpectedRemaining > 0)

                    {
                        this.currentPointer++;

                        tag = RESOURCE_HEADER_TAG;

                        ContinueProcessing();
                    }

                    else

                    {
                        OnMessageParsed();
                    }
                }



                else if (tag == ENCRYPTED_HEADERS_TAG)

                {
                    // see if a length was specified (the original spec did not require the main encrypted headers portion to specify a length)

                    if (s.StartsWith(Header.RESOURCE_LENGTH))

                    {
                        Header header = Header.ParseHeader(s);

                        if (header != null)

                        {
                            int len = Convert.ToInt32(header.Value);

                            tag = ENCRYPTED_HEADERS_TAG;

                            ContinueProcessing();
                        }
                    }



                    ParseEncryptedMessage(data.ByteArray);

                    if (this.pointersExpected > 0)

                    {
                        tag = RESOURCE_HEADER_TAG;

                        ContinueProcessing();
                    }

                    else

                    {
                        OnMessageParsed();
                    }
                }



                else

                {
                    OnError(ErrorCode.INVALID_REQUEST, ErrorDescription.MALFORMED_REQUEST);
                }
            }

            catch (GrowlException gEx)

            {
                OnError(gEx.ErrorCode, gEx.Message, gEx.AdditionalInfo);
            }

            catch (Exception ex)

            {
                OnError(ErrorCode.INVALID_REQUEST, ErrorDescription.MALFORMED_REQUEST, ex.Message);
            }
        }
Exemple #10
0
        private void Test_Register(string testName, Growl.Connector.Application app, List <NotificationType> types, Cryptography.SymmetricAlgorithmType ea, Cryptography.HashAlgorithmType ha)

        {
            GrowlConnector g = new GrowlConnector(this.textBox2.Text);

            g.EncryptionAlgorithm = ea;

            g.KeyHashAlgorithm = ha;



            //string r = g.Register(app, types.ToArray());



            //WriteTestRequest(r);
        }
Exemple #11
0
 public GrowlManager(string password, string hostname, int port, Cryptography.SymmetricAlgorithmType encryptionAlgorithm = Cryptography.SymmetricAlgorithmType.PlainText)
     : base(password, hostname, port, encryptionAlgorithm)
 {
 }
Exemple #12
0
 public GrowlManager(string password, Cryptography.SymmetricAlgorithmType encryptionAlgorithm = Cryptography.SymmetricAlgorithmType.PlainText)
     : base(password, encryptionAlgorithm)
 {
 }
Exemple #13
0
 public GrowlManager(Cryptography.SymmetricAlgorithmType encryptionAlgorithm = Cryptography.SymmetricAlgorithmType.PlainText)
     : base(encryptionAlgorithm)
 {
 }
Exemple #14
0
        /// <summary>

        /// Checks the supplied <paramref name="keyHash"/> against all of the stored passwords to

        /// see if the hash is valid, and retuns the matching <see cref="Key"/> if a match is found.

        /// </summary>

        /// <param name="keyHash">The hex-encoded hash to validate</param>

        /// <param name="salt">The hex-encoded salt value</param>

        /// <param name="hashAlgorithm">The <see cref="Cryptography.HashAlgorithmType"/> used to generate the hash</param>

        /// <param name="encryptionAlgorithm">The <see cref="Cryptography.SymmetricAlgorithmType"/> used by this key to do encryption/decryption</param>

        /// <param name="matchingKey">Contains the matching <see cref="Key"/> if a match is found</param>

        /// <returns>

        /// <c>true</c> if the hash matches one of the stored password/key values;

        /// <c>false</c> if no match is found

        /// If no match is found, <paramref name="matchingKey"/> will return <c>null</c>.

        /// </returns>

        public bool IsValid(string keyHash, string salt, Cryptography.HashAlgorithmType hashAlgorithm, Cryptography.SymmetricAlgorithmType encryptionAlgorithm, out Key matchingKey)

        {
            matchingKey = null;



            if (String.IsNullOrEmpty(keyHash))
            {
                return(false);
            }



            keyHash = keyHash.ToUpper();

            foreach (Password password in this.passwords.Values)

            {
                bool match = Key.Compare(password.ActualPassword, keyHash, salt, hashAlgorithm, encryptionAlgorithm, out matchingKey);

                if (match)

                {
                    return(true);
                }
            }

            return(false);
        }
Exemple #15
0
        public static int Main(string[] args)

        {
            if (args == null || args.Length == 0)

            {
                Console.WriteLine("Invalid arguments. See /? for usage.");

                return(-1);
            }

            else if (args[0] == "/?")

            {
                Console.WriteLine();

                Console.WriteLine(Resources.usage);

                return(0);
            }

            else

            {
                Dictionary <string, Program.Parameter> dictionary = new Dictionary <string, Program.Parameter>();

                try

                {
                    foreach (string str in args)

                    {
                        Program.Parameter parameterValue = Program.GetParameterValue(str);

                        dictionary.Add(parameterValue.Argument, parameterValue);
                    }
                }

                catch (Exception ex)

                {
                    Console.WriteLine("Bad arguments : " + ex.Message);

                    return(-1);
                }

                string title = "growlnotify";

                string id = "";

                string coalescingID = (string)null;

                bool sticky = false;

                int num = 0;

                string str1 = (string)null;

                string str2 = "growlnotify";

                string uriString = (string)null;

                string[] strArray1 = (string[])null;

                string notificationName = "General Notification";

                string url = (string)null;

                string str3 = "GNTP";

                string hostname = "localhost";

                string password = (string)null;

                Cryptography.SymmetricAlgorithmType symmetricAlgorithmType = Cryptography.SymmetricAlgorithmType.PlainText;

                Cryptography.HashAlgorithmType hashAlgorithmType = Cryptography.HashAlgorithmType.MD5;

                int port = 23053;

                if (!dictionary.ContainsKey("messagetext"))

                {
                    Console.WriteLine("Missing 'messagetext' argument. See /? for usage");

                    return(-1);
                }

                else

                {
                    string text = dictionary["messagetext"].Value;

                    if (dictionary.ContainsKey("/t"))
                    {
                        title = dictionary["/t"].Value;
                    }

                    if (dictionary.ContainsKey("/id"))
                    {
                        id = dictionary["/id"].Value;
                    }

                    if (dictionary.ContainsKey("/s") && dictionary["/s"].Value.ToLower() == "true")
                    {
                        sticky = true;
                    }

                    if (dictionary.ContainsKey("/p"))
                    {
                        num = Convert.ToInt32(dictionary["/p"].Value);
                    }

                    if (dictionary.ContainsKey("/i"))

                    {
                        str1 = dictionary["/i"].Value;

                        if (str1.StartsWith("."))
                        {
                            str1 = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), str1);
                        }
                    }

                    if (dictionary.ContainsKey("/c"))
                    {
                        coalescingID = dictionary["/c"].Value;
                    }

                    if (dictionary.ContainsKey("/a"))
                    {
                        str2 = dictionary["/a"].Value;
                    }

                    if (dictionary.ContainsKey("/ai"))

                    {
                        uriString = dictionary["/ai"].Value;

                        if (uriString.StartsWith("."))
                        {
                            uriString = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), str1);
                        }
                    }

                    if (dictionary.ContainsKey("/r"))

                    {
                        string[] strArray2 = dictionary["/r"].Value.Split(new char[1]

                        {
                            ','
                        });

                        if (strArray2 != null && strArray2.Length > 0)

                        {
                            strArray1 = new string[strArray2.Length];

                            for (int index = 0; index < strArray2.Length; ++index)

                            {
                                string str4 = strArray2[index];

                                if (str4.StartsWith("\""))
                                {
                                    str4 = str4.Substring(1, str4.Length - 1);
                                }

                                if (str4.EndsWith("\""))
                                {
                                    str4 = str4.Substring(0, str4.Length - 1);
                                }

                                strArray1[index] = str4;
                            }
                        }
                    }

                    if (dictionary.ContainsKey("/n"))
                    {
                        notificationName = dictionary["/n"].Value;
                    }

                    if (dictionary.ContainsKey("/cu"))
                    {
                        url = dictionary["/cu"].Value;
                    }

                    if (dictionary.ContainsKey("/protocol"))
                    {
                        str3 = dictionary["/protocol"].Value;
                    }

                    if (dictionary.ContainsKey("/host"))
                    {
                        hostname = dictionary["/host"].Value;
                    }

                    if (dictionary.ContainsKey("/port"))
                    {
                        port = Convert.ToInt32(dictionary["/port"].Value);
                    }

                    else if (str3 == "UDP")
                    {
                        port = 9887;
                    }

                    if (dictionary.ContainsKey("/pass"))
                    {
                        password = dictionary["/pass"].Value;
                    }

                    if (dictionary.ContainsKey("/enc"))

                    {
                        switch (dictionary["/enc"].Value.ToUpper())

                        {
                        case "DES":

                            symmetricAlgorithmType = Cryptography.SymmetricAlgorithmType.DES;

                            break;

                        case "3DES":

                            symmetricAlgorithmType = Cryptography.SymmetricAlgorithmType.TripleDES;

                            break;

                        case "AES":

                            symmetricAlgorithmType = Cryptography.SymmetricAlgorithmType.AES;

                            break;

                        default:

                            symmetricAlgorithmType = Cryptography.SymmetricAlgorithmType.PlainText;

                            break;
                        }
                    }

                    if (dictionary.ContainsKey("/hash"))

                    {
                        switch (dictionary["/hash"].Value.ToUpper())

                        {
                        case "SHA1":

                            hashAlgorithmType = Cryptography.HashAlgorithmType.SHA1;

                            break;

                        case "SHA256":

                            hashAlgorithmType = Cryptography.HashAlgorithmType.SHA256;

                            break;

                        case "SHA512":

                            hashAlgorithmType = Cryptography.HashAlgorithmType.SHA512;

                            break;

                        default:

                            hashAlgorithmType = Cryptography.HashAlgorithmType.MD5;

                            break;
                        }
                    }

                    if (dictionary.ContainsKey("/silent") && dictionary["/silent"].Value.ToLower() == "true")
                    {
                        Program.silent = true;
                    }

                    Program.ewh = new EventWaitHandle(false, EventResetMode.ManualReset);

                    Program.growl = new GrowlConnector(password, hostname, port);

                    Program.growl.EncryptionAlgorithm = symmetricAlgorithmType;

                    Program.growl.KeyHashAlgorithm = hashAlgorithmType;

                    Program.growl.OKResponse += new GrowlConnector.ResponseEventHandler(Program.growl_Response);

                    Program.growl.ErrorResponse += new GrowlConnector.ResponseEventHandler(Program.growl_Response);

                    if (strArray1 != null || str2 == "growlnotify")

                    {
                        Resource resource = (Resource)null;

                        if (!string.IsNullOrEmpty(uriString))

                        {
                            Uri uri = new Uri(uriString);

                            resource = !uri.IsFile || !File.Exists(uri.LocalPath) ? (Resource)uriString : (Resource)ImageConverter.ImageFromUrl(uri.LocalPath);
                        }

                        if (strArray1 == null)
                        {
                            strArray1 = new string[1]

                            {
                                "General Notification"
                            }
                        }
                        ;

                        NotificationType[] notificationTypes = new NotificationType[strArray1.Length];

                        for (int index = 0; index < notificationTypes.Length; ++index)

                        {
                            NotificationType notificationType = new NotificationType(strArray1[index]);

                            notificationTypes[index] = notificationType;
                        }

                        Program.growl.Register(new Application(str2)

                        {
                            Icon = resource
                        }, notificationTypes);

                        Program.ewh.WaitOne();
                    }

                    CallbackContext callbackContext = (CallbackContext)null;

                    if (!string.IsNullOrEmpty(url))
                    {
                        callbackContext = new CallbackContext(url);
                    }

                    Program.ewh.Reset();

                    Resource icon = (Resource)null;

                    if (!string.IsNullOrEmpty(str1))

                    {
                        Uri uri = new Uri(str1);

                        icon = !uri.IsFile || !File.Exists(uri.LocalPath) ? (Resource)str1 : (Resource)ImageConverter.ImageFromUrl(uri.LocalPath);
                    }

                    Priority priority = Enum.IsDefined(typeof(Priority), (object)num) ? (Priority)num : Priority.Normal;

                    Notification notification = new Notification(str2, notificationName, id, title, text, icon, sticky, priority, coalescingID);

                    Program.growl.Notify(notification, callbackContext);

                    Program.ewh.WaitOne();

                    Console.WriteLine();

                    return(Program.r);
                }
            }
        }
        /// <summary>

        /// Initializes a new instance of the <see cref="SubscriberKey"/> class.

        /// </summary>

        /// <param name="key">The <see cref="Key"/> to base this key upon.</param>

        /// <param name="subscriberID">The unique subscriber ID</param>

        /// <param name="hashAlgorithm">The <see cref="Cryptography.HashAlgorithmType"/> used when hashing values</param>

        /// <param name="encryptionAlgorithm">The <see cref="Cryptography.SymmetricAlgorithmType"/> used when encrypting values</param>

        public SubscriberKey(Key key, string subscriberID, Cryptography.HashAlgorithmType hashAlgorithm, Cryptography.SymmetricAlgorithmType encryptionAlgorithm)

            : base(key.Password + subscriberID, hashAlgorithm, encryptionAlgorithm)

        {
        }
        private void ProcessBuffer()
        {
            try
            {
                Data data = new Data(buffer.ToArray());
                string s = data.ToString();
                alreadyReceived.Append(s);

                if (tag == START_TAG)
                {
                    // start looking for GNTP header
                    tag = GNTP_IDENTIFIER_TAG;
                    ContinueProcessing();
                }

                else if (tag == GNTP_IDENTIFIER_TAG)
                {
                    string line = s;
                    Match match = ParseGNTPHeaderLine(line, this.passwordRequired);

                    if (match.Success)
                    {
                        this.version = match.Groups["Version"].Value;
                        if (version == MessageParser.GNTP_SUPPORTED_VERSION)
                        {
                            string d = match.Groups["Directive"].Value;
                            if (Enum.IsDefined(typeof(RequestType), d))
                            {
                                this.directive = (RequestType)Enum.Parse(typeof(RequestType), d);

                                // check for supported but not allowed requests
                                if (this.directive == RequestType.SUBSCRIBE && !this.allowSubscriptions)
                                {
                                    OnError(ErrorCode.NOT_AUTHORIZED, ErrorDescription.SUBSCRIPTIONS_NOT_ALLOWED);
                                }
                                else
                                {
                                    this.encryptionAlgorithm = Cryptography.GetEncryptionType(match.Groups["EncryptionAlgorithm"].Value);
                                    this.ivHex = (match.Groups["IV"] != null ? match.Groups["IV"].Value : null);
                                    if (!String.IsNullOrEmpty(this.ivHex)) this.iv = Cryptography.HexUnencode(this.ivHex);
                                    string keyHash = match.Groups["KeyHash"].Value.ToUpper();

                                    bool authorized = false;
                                    // Any of the following criteria require a password:
                                    //    1. the request did not originate on the local machine or LAN
                                    //    2. the request came from the LAN, but LAN passwords are required
                                    //    2. it is a SUBSCRIBE request (all subscriptions require a password)
                                    //    3. the user's preferences require even local requests to supply a password
                                    // Additionally, even if a password is not required, it will be validated if the
                                    // sending appplication includes one
                                    string errorDescription = ErrorDescription.INVALID_KEY;
                                    if (this.passwordRequired || this.directive == RequestType.SUBSCRIBE || !String.IsNullOrEmpty(keyHash))
                                    {
                                        if (String.IsNullOrEmpty(keyHash))
                                        {
                                            errorDescription = ErrorDescription.MISSING_KEY;
                                        }
                                        else
                                        {
                                            string keyHashAlgorithmType = match.Groups["KeyHashAlgorithm"].Value;
                                            this.keyHashAlgorithm = Cryptography.GetKeyHashType(keyHashAlgorithmType);
                                            string salt = match.Groups["Salt"].Value.ToUpper();
                                            authorized = this.passwordManager.IsValid(keyHash, salt, this.keyHashAlgorithm, this.encryptionAlgorithm, out this.key);
                                        }
                                    }
                                    else
                                    {
                                        authorized = true;
                                        this.key = Key.None;
                                    }

                                    if (authorized)
                                    {
                                        if (this.encryptionAlgorithm == Cryptography.SymmetricAlgorithmType.PlainText)
                                        {
                                            tag = HEADER_TAG;
                                            ContinueProcessing();
                                        }
                                        else
                                        {
                                            tag = ENCRYPTED_HEADERS_TAG;
                                            ContinueProcessing();
                                        }
                                    }
                                    else
                                    {
                                        OnError(ErrorCode.NOT_AUTHORIZED, errorDescription);
                                    }
                                }
                            }
                            else
                            {
                                OnError(ErrorCode.INVALID_REQUEST, ErrorDescription.UNSUPPORTED_DIRECTIVE, d);
                            }
                        }
                        else
                        {
                            OnError(ErrorCode.UNKNOWN_PROTOCOL_VERSION, ErrorDescription.UNSUPPORTED_VERSION, version);
                        }
                    }
                    else
                    {
                        OnError(ErrorCode.UNKNOWN_PROTOCOL, ErrorDescription.MALFORMED_REQUEST);
                    }
                }

                else if (tag == HEADER_TAG)
                {
                    if (s == MessageParser.BLANK_LINE)
                    {
                        // if this is a REGISTER message, check Notifications-Count value
                        // to see how many notification sections to expect
                        if (this.directive == RequestType.REGISTER)
                        {
                            if (this.expectedNotifications > 0)
                            {
                                tag = NOTIFICATION_TYPE_TAG;
                                ContinueProcessing();
                            }
                            else
                            {
                                // a REGISTER request with no notifications is not valid
                                OnError(ErrorCode.INVALID_REQUEST, ErrorDescription.NO_NOTIFICATIONS_REGISTERED);
                            }
                        }
                        else
                        {
                            // otherwise, check the number of resource pointers we got and start reading those
                            this.pointersExpected = GetNumberOfPointers();
                            if (this.pointersExpected > 0)
                            {
                                this.pointersExpectedRemaining = this.pointersExpected;
                                this.currentPointer = 1;
                                tag = RESOURCE_HEADER_TAG;
                                ContinueProcessing();
                            }
                            else
                            {
                                OnMessageParsed();
                            }
                        }
                    }
                    else
                    {
                        Header header = Header.ParseHeader(s);
                        if (header != null)
                        {
                            bool addHeader = true;
                            if (header.Name == Header.APPLICATION_NAME)
                            {
                                this.applicationName = header.Value;
                            }
                            if (header.Name == Header.NOTIFICATIONS_COUNT)
                            {
                                this.expectedNotifications = Convert.ToInt32(header.Value);
                                this.expectedNotificationsRemaining = this.expectedNotifications;
                                this.currentNotification = 1;
                            }
                            if (header.Name == Header.NOTIFICATION_CALLBACK_CONTEXT)
                            {
                                this.callbackData = header.Value;
                            }
                            if (header.Name == Header.NOTIFICATION_CALLBACK_CONTEXT_TYPE)
                            {
                                this.callbackDataType = header.Value;
                            }
                            if (header.Name == Header.NOTIFICATION_CALLBACK_TARGET || header.Name == Header.NOTIFICATION_CALLBACK_CONTEXT_TARGET)   // left in for compatibility
                            {
                                this.callbackUrl = header.Value;
                            }
                            if (header.Name == Header.RECEIVED)
                            {
                                this.requestInfo.PreviousReceivedHeaders.Add(header);
                                addHeader = false;
                            }

                            if (addHeader) this.headers.AddHeader(header);
                        }
                        tag = HEADER_TAG;
                        ContinueProcessing();
                    }
                }

                else if (tag == NOTIFICATION_TYPE_TAG)
                {
                    if (s == MessageParser.BLANK_LINE)
                    {
                        this.expectedNotificationsRemaining--;
                        if (this.expectedNotificationsRemaining > 0)
                        {
                            this.currentNotification++;
                            tag = NOTIFICATION_TYPE_TAG;
                            ContinueProcessing();
                        }
                        else
                        {
                            // otherwise, check the number of resource pointers we got and start reading those
                            this.pointersExpected = GetNumberOfPointers();
                            if (this.pointersExpected > 0)
                            {
                                this.pointersExpectedRemaining = this.pointersExpected;
                                this.currentPointer = 1;
                                tag = RESOURCE_HEADER_TAG;
                                ContinueProcessing();
                            }
                            else
                            {
                                OnMessageParsed();
                            }
                        }
                    }
                    else
                    {
                        if (this.notificationsToBeRegistered.Count < this.currentNotification)
                        {
                            this.notificationsToBeRegistered.Add(new HeaderCollection());
                        }

                        Header header = Header.ParseHeader(s);
                        this.notificationsToBeRegistered[this.currentNotification - 1].AddHeader(header);
                        tag = NOTIFICATION_TYPE_TAG;
                        ContinueProcessing();
                    }
                }

                else if (tag == RESOURCE_HEADER_TAG)
                {
                    if (s == MessageParser.BLANK_LINE)
                    {
                        // we should have found an Identifier header and Length header, or we are just starting a new section
                        Pointer p = this.pointers[this.currentPointer - 1];
                        if (p.Identifier != null && p.Length > 0)
                        {
                            // read #of bytes
                            int length = this.pointers[this.currentPointer - 1].Length;
                            tag = RESOURCE_TAG;
                            ContinueProcessing();
                        }
                        else
                        {
                            tag = RESOURCE_HEADER_TAG;
                            ContinueProcessing();
                        }
                    }
                    else
                    {
                        Header header = Header.ParseHeader(s);
                        // should be Identifer or Length
                        if (header != null)
                        {
                            bool validHeader = false;
                            if (header.Name == Header.RESOURCE_IDENTIFIER)
                            {
                                this.pointers[this.currentPointer - 1].Identifier = header.Value;
                                validHeader = true;
                            }
                            else if (header.Name == Header.RESOURCE_LENGTH)
                            {
                                this.pointers[this.currentPointer - 1].Length = Convert.ToInt32(header.Value);
                                validHeader = true;
                            }
                            else
                            {
                                OnError(ErrorCode.INVALID_REQUEST, ErrorDescription.UNRECOGNIZED_RESOURCE_HEADER, header.Name);
                            }

                            if (validHeader)
                            {
                                tag = RESOURCE_HEADER_TAG;
                                ContinueProcessing();
                            }
                        }
                        else
                        {
                            OnError(ErrorCode.INVALID_REQUEST, ErrorDescription.UNRECOGNIZED_RESOURCE_HEADER);
                        }
                    }
                }

                else if (tag == RESOURCE_TAG)
                {
                    // deal with data bytes
                    byte[] bytes = this.key.Decrypt(data.ByteArray, this.iv);

                    Pointer pointer = this.pointers[this.currentPointer - 1];
                    pointer.ByteArray = bytes;
                    BinaryData binaryData = new BinaryData(pointer.Identifier, pointer.ByteArray);
                    ResourceCache.Add(this.applicationName, binaryData);

                    this.pointersExpectedRemaining--;
                    if (this.pointersExpectedRemaining > 0)
                    {
                        this.currentPointer++;
                        tag = RESOURCE_HEADER_TAG;
                        ContinueProcessing();
                    }
                    else
                    {
                        OnMessageParsed();
                    }
                }

                else if (tag == ENCRYPTED_HEADERS_TAG)
                {
                    // see if a length was specified (the original spec did not require the main encrypted headers portion to specify a length)
                    if (s.StartsWith(Header.RESOURCE_LENGTH))
                    {
                        Header header = Header.ParseHeader(s);
                        if (header != null)
                        {
                            int len = Convert.ToInt32(header.Value);
                            tag = ENCRYPTED_HEADERS_TAG;
                            ContinueProcessing();
                        }
                    }

                    ParseEncryptedMessage(data.ByteArray);
                    if (this.pointersExpected > 0)
                    {
                        tag = RESOURCE_HEADER_TAG;
                        ContinueProcessing();
                    }
                    else
                    {
                        OnMessageParsed();
                    }
                }

                else
                {
                    OnError(ErrorCode.INVALID_REQUEST, ErrorDescription.MALFORMED_REQUEST);
                }
            }
            catch (GrowlException gEx)
            {
                OnError(gEx.ErrorCode, gEx.Message, gEx.AdditionalInfo);
            }
            catch (Exception ex)
            {
                OnError(ErrorCode.INVALID_REQUEST, ErrorDescription.MALFORMED_REQUEST, ex.Message);
            }
        }
Exemple #18
0
 /// <summary>
 /// デフォルトコンストラクタ
 /// </summary>
 /// <param name="encryptionAlgorithm">
 /// 通知メッセージの暗号化タイプを指定。
 /// デフォルトは「plaintext」
 /// </param>
 public GrowlManagerBase(Cryptography.SymmetricAlgorithmType encryptionAlgorithm = Cryptography.SymmetricAlgorithmType.PlainText)
     : this("", encryptionAlgorithm)
 {
 }