Esempio n. 1
0
        /// <summary>
        /// Deserializes an endpoint from an address book entry and validates that the signatures are correct.
        /// </summary>
        /// <returns>The deserialized endpoint.</returns>
        /// <exception cref="BadAddressBookEntryException">Thrown if the signatures are invalid.</exception>
        public Endpoint ExtractEndpoint()
        {
            var reader = new BinaryReader(new MemoryStream(this.SerializedEndpoint));
            Endpoint endpoint;
            try
            {
                endpoint = reader.DeserializeDataContract<Endpoint>();
            }
            catch (SerializationException ex)
            {
                throw new BadAddressBookEntryException(ex.Message, ex);
            }

            try
            {
                if (!CryptoProviderExtensions.VerifySignatureWithTolerantHashAlgorithm(endpoint.SigningKeyPublicMaterial, this.SerializedEndpoint, this.Signature, this.HashAlgorithmName != null ? (AsymmetricAlgorithm?)CryptoProviderExtensions.GetSignatureProvider(this.HashAlgorithmName) : null))
                {
                    throw new BadAddressBookEntryException(Strings.AddressBookEntrySignatureDoesNotMatch);
                }
            }
            catch (Exception ex)
            { // all those platform-specific exceptions that aren't available to portable libraries.
                throw new BadAddressBookEntryException(Strings.AddressBookEntrySignatureDoesNotMatch, ex);
            }

            return endpoint;
        }
Esempio n. 2
0
		/// <summary>
		/// Loads endpoint information including private data from the specified stream.
		/// </summary>
		/// <param name="stream">A stream, previously serialized to using <see cref="SaveAsync"/>.</param>
		/// <returns>A task whose result is the deserialized instance of <see cref="OwnEndpoint"/>.</returns>
		public static async Task<OwnEndpoint> OpenAsync(Stream stream) {
			Requires.NotNull(stream, "stream");

			var ms = new MemoryStream();
			await stream.CopyToAsync(ms); // relies on the input stream containing only the endpoint.
			ms.Position = 0;
			using (var reader = new BinaryReader(ms)) {
				return reader.DeserializeDataContract<OwnEndpoint>();
			}
		}
Esempio n. 3
0
		/// <summary>
		/// Deserializes an endpoint from an address book entry and validates that the signatures are correct.
		/// </summary>
		/// <param name="cryptoProvider">The cryptographic provider that will be used to verify the signature.</param>
		/// <returns>The deserialized endpoint.</returns>
		/// <exception cref="BadAddressBookEntryException">Thrown if the signatures are invalid.</exception>
		public Endpoint ExtractEndpoint(ICryptoProvider cryptoProvider) {
			Requires.NotNull(cryptoProvider, "cryptoProvider");

			var reader = new BinaryReader(new MemoryStream(this.SerializedEndpoint));
			Endpoint endpoint;
			try {
				endpoint = reader.DeserializeDataContract<Endpoint>();
			} catch (SerializationException ex) {
				throw new BadAddressBookEntryException(ex.Message, ex);
			}

			try {
				if (!cryptoProvider.VerifySignature(endpoint.SigningKeyPublicMaterial, this.SerializedEndpoint, this.Signature)) {
					throw new BadAddressBookEntryException(Strings.AddressBookEntrySignatureDoesNotMatch);
				}
			} catch (Exception ex) { // all those platform-specific exceptions that aren't available to portable libraries.
				throw new BadAddressBookEntryException(Strings.AddressBookEntrySignatureDoesNotMatch, ex);
			}

			return endpoint;
		}
Esempio n. 4
0
 private async void OpenOwnEndpoint_OnClick(object sender, RoutedEventArgs e)
 {
     this.OpenOwnEndpoint.IsEnabled = false;
     this.OpenOwnEndpoint.Cursor = Cursors.AppStarting;
     try
     {
         var dialog = new OpenFileDialog();
         bool? result = dialog.ShowDialog(this);
         if (result.HasValue && result.Value)
         {
             using (var fileStream = dialog.OpenFile())
             {
                 var reader = new BinaryReader(fileStream, Encoding.UTF8);
                 var addressBookEntry = reader.DeserializeDataContract<Uri>();
                 await this.SetEndpointAsync(await OwnEndpoint.OpenAsync(fileStream), addressBookEntry);
             }
         }
     }
     finally
     {
         this.OpenOwnEndpoint.Cursor = Cursors.Arrow;
         this.OpenOwnEndpoint.IsEnabled = true;
     }
 }
Esempio n. 5
0
		/// <summary>
		/// Extracts a message from its serialized payload wrapper.
		/// </summary>
		/// <param name="payload">The payload to extract the message from.</param>
		/// <returns>The extracted message.</returns>
		private static Message FromPayload(Payload payload) {
			Requires.NotNull(payload, "payload");

			if (payload.ContentType != Message.ContentType) {
				return null;
			}

			using (var reader = new BinaryReader(new MemoryStream(payload.Content))) {
				var message = reader.DeserializeDataContract<Message>();
				message.OriginatingPayload = payload;
				return message;
			}
		}
Esempio n. 6
0
        /// <summary>
        /// Extracts a message from its serialized payload wrapper.
        /// </summary>
        /// <param name="payloadReceipt">The payload to extract the message from.</param>
        /// <returns>The extracted message.</returns>
        private static MessageReceipt FromPayload(Channel.PayloadReceipt payloadReceipt)
        {
            Requires.NotNull(payloadReceipt, "payloadReceipt");

            var payload = payloadReceipt.Payload;
            if (payload.ContentType != Message.ContentType)
            {
                return null;
            }

            using (var reader = new BinaryReader(new MemoryStream(payload.Content)))
            {
                var message = reader.DeserializeDataContract<Message>();
                message.OriginatingPayload = payload;
                return new MessageReceipt(message, payloadReceipt.DateNotificationPosted);
            }
        }