def answer_challenge(connection, authkey): import hmac assert isinstance(authkey, bytes) message = connection.recv_bytes(256) # reject large message assert message[:len(CHALLENGE)] == CHALLENGE, 'message = %r' % message message = message[len(CHALLENGE):] digest = hmac.new(authkey, message).digest() connection.send_bytes(digest) response = connection.recv_bytes(256) # reject large message if response != WELCOME: raise AuthenticationError('digest sent was rejected')
def deliver_challenge(connection, authkey): import hmac message = os.urandom(MESSAGE_LENGTH) connection.send_bytes(CHALLENGE + message) digest = hmac.new(authkey, message).digest() response = connection.recv_bytes(256) if response == digest: connection.send_bytes(WELCOME) else: connection.send_bytes(FAILURE) raise AuthenticationError('digest received was wrong')
def answer_challenge(connection, authkey): import hmac raise isinstance(authkey, bytes) or AssertionError message = connection.recv_bytes(256) if not message[:len(CHALLENGE)] == CHALLENGE: raise AssertionError('message = %r' % message) message = message[len(CHALLENGE):] digest = hmac.new(authkey, message).digest() connection.send_bytes(digest) response = connection.recv_bytes(256) raise response != WELCOME and AuthenticationError('digest sent was rejected')
def deliver_challenge(connection, authkey): import hmac assert isinstance(authkey, bytes) message = os.urandom(MESSAGE_LENGTH) connection.send_bytes(CHALLENGE + message) digest = hmac.new(authkey, message, get_digestmod_for_hmac()).digest() response = connection.recv_bytes(256) # reject large message if response == digest: connection.send_bytes(WELCOME) else: connection.send_bytes(FAILURE) raise AuthenticationError('digest received was wrong')
async def challengeReply(self) -> None: """Server replies to client challenges""" message = await self.reader.readexactly(CHALLENGE_SEND_LEN) assert message[: len(CHALLENGE)] == CHALLENGE, f"message = {message!r}" message = message[len(CHALLENGE) :] digest = hmac.new(self.authKey, message, HASH_ALGO).digest() self.writer.write(digest) await self.writer.drain() response = await self.reader.readexactly(len(WELCOME)) if response != WELCOME: raise AuthenticationError("digest sent was rejected")
async def deliver_challenge(self, authkey: bytes): import hmac if not isinstance(authkey, bytes): raise ValueError("Authkey must be bytes, not {0!s}".format( type(authkey))) message = os.urandom(MESSAGE_LENGTH) await self.send_bytes(CHALLENGE + message) digest = hmac.new(authkey, message, 'md5').digest() response = await self.recv_bytes(256) # reject large message if response == digest: await self.send_bytes(WELCOME) else: await self.send_bytes(FAILURE) raise AuthenticationError('digest received was wrong')
async def challengeSend(self) -> None: """Client sends challenge to server when client connects""" message = os.urandom(RANDBYTES_LEN) self.writer.write(CHALLENGE + message) await self.writer.drain() digest = hmac.new(self.authKey, message, HASH_ALGO).digest() response = await self.reader.readexactly(CHALLENGE_REPLY_LEN) if response == digest: self.writer.write(WELCOME) await self.writer.drain() else: self.writer.write(FAILURE) await self.writer.drain() raise AuthenticationError("digest received didn't verify?")
def send_message( self, recipients: Optional[Union[List[str], str]] = None, subject: Optional[str] = "", body: Optional[str] = "", attachments: Optional[Union[List[str], str]] = None, html: Optional[bool] = False, images: Optional[Union[List[str], str]] = None, cc: Optional[Union[List[str], str]] = None, bcc: Optional[Union[List[str], str]] = None, save: Optional[bool] = False, ) -> None: """Keyword for sending message through connected Exchange account. :param recipients: list of email addresses :param subject: message subject, defaults to "" :param body: message body, defaults to "" :param attachments: list of filepaths to attach, defaults to `None` :param html: if message content is in HTML, default `False` :param images: list of filepaths for inline use, defaults to `None` :param cc: list of email addresses :param bcc: list of email addresses :param save: is sent message saved to Sent messages folder or not, defaults to False Email addresses can be prefixed with ``ex:`` to indicate an Exchange account address. At least one target needs to exist for `recipients`, `cc` or `bcc`. """ if not self.account: raise AuthenticationError("Not authorized to any Exchange account") recipients, cc, bcc, attachments, images = self._handle_message_parameters( recipients, cc, bcc, attachments, images) if not recipients and not cc and not bcc: raise NoRecipientsError( "Atleast one address is required for 'recipients', 'cc' or 'bcc' parameter" # noqa: E501 ) self.logger.info("Sending message to %s", ",".join(recipients)) m = Message( account=self.account, subject=subject, body=body, to_recipients=recipients, cc_recipients=cc, bcc_recipients=bcc, ) self._add_attachments_to_msg(attachments, m) self._add_images_inline_to_msg(images, html, body, m) if html: m.body = HTMLBody(body) else: m.body = body # TODO. The exchangelib does not seem to provide any straightforward way of # verifying if message was sent or not if save: m.folder = self.account.sent m.send_and_save() else: m.send()
async def handler(start_event: asyncio.Event) -> None: log.debug("Starting to handle client") packet_type, salt = await receive() assert packet_type == PacketTypes.AUTH_SALT packet_type, digest = await receive() assert packet_type == PacketTypes.AUTH_DIGEST hasher = HASHER() hasher.update(salt) hasher.update(self.__cookie) if digest != hasher.digest(): exc = AuthenticationError("Invalid cookie") await send(PacketTypes.EXCEPTION, exc) raise exc await send(PacketTypes.AUTH_OK, True) log.debug("Client authorized") packet_type, identity = await receive() assert packet_type == PacketTypes.IDENTITY process = self.__spawning.pop(identity) starting: asyncio.Future = self.__starting.pop(identity) if self.initializer is not None: initializer_done = self.__create_future() await step(self.initializer, self.initializer_args, dict(self.initializer_kwargs), initializer_done) try: await initializer_done except Exception as e: starting.set_exception(e) raise else: starting.set_result(None) finally: start_event.set() else: starting.set_result(None) start_event.set() while True: func: Callable args: Tuple[Any, ...] kwargs: Dict[str, Any] result_future: asyncio.Future process_future: asyncio.Future ( func, args, kwargs, result_future, process_future, ) = await self.tasks.get() try: if process_future.done(): continue process_future.set_result(process) if result_future.done(): continue await step(func, args, kwargs, result_future) except asyncio.IncompleteReadError: await self.__wait_process(process) self.__on_exit(process) result_future.set_exception( ProcessError( "Process {!r} exited with code {!r}".format( process, process.returncode, ), ), ) break except Exception as e: if not result_future.done(): self.loop.call_soon(result_future.set_exception, e) if not writer.is_closing(): self.loop.call_soon(writer.close) await self.__wait_process(process) self.__on_exit(process) raise