<?xml version="1.0" encoding="UTF-8"?>
<xliff xmlns="urn:oasis:names:tc:xliff:document:1.1" version="1.1">
  <file original="NoName" source-language="en" datatype="plaintext" target-language="en">
    <body>
      <trans-unit xml:space="preserve" approved="no" id="418bf0d2bd3c575b" weblate-flags="read-only">
        <source>Remote login</source>
        <target state="translated">Remote login</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../protocols/ssh.rst</context>
          <context context-type="linenumber">9</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="32d67750f819d7fe" weblate-flags="read-only">
        <source>One of the initial motivations for building computer networks was to allow users to access remote computers over the networks. In the 1960s and 1970s, the mainframes and the emerging minicomputers were composed of a central unit and a set of terminals connected through serial lines or modems. The simplest protocol that was designed to access remote computers over a network is probably :term:`telnet` :rfc:`854`. :term:`telnet` runs over TCP and a telnet server listens on port `23` by default. The TCP connection used by telnet is bidirectional, both the client and the server can send data over it. The data exchanged over such a connection is essentially the characters that are typed by the user on the client machine and the text output of the processes running on the server machine with a few exceptions (e.g. control characters, characters to control the terminal like VT-100, ...) . The default character set for telnet is the ASCII character set, but the extensions specified in :rfc:`5198` support the utilization of Unicode characters.</source>
        <target state="translated">One of the initial motivations for building computer networks was to allow users to access remote computers over the networks. In the 1960s and 1970s, the mainframes and the emerging minicomputers were composed of a central unit and a set of terminals connected through serial lines or modems. The simplest protocol that was designed to access remote computers over a network is probably :term:`telnet` :rfc:`854`. :term:`telnet` runs over TCP and a telnet server listens on port `23` by default. The TCP connection used by telnet is bidirectional, both the client and the server can send data over it. The data exchanged over such a connection is essentially the characters that are typed by the user on the client machine and the text output of the processes running on the server machine with a few exceptions (e.g. control characters, characters to control the terminal like VT-100, ...) . The default character set for telnet is the ASCII character set, but the extensions specified in :rfc:`5198` support the utilization of Unicode characters.</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../protocols/ssh.rst</context>
          <context context-type="linenumber">11</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="d39a10f4a8accfd2" weblate-flags="read-only">
        <source>From a security viewpoint, the main drawback of :term:`telnet` is that all the information, including the usernames, passwords and commands, is sent in cleartext over a TCP connection. This implies that an eavesdropper could easily capture the passwords used by anyone on an unprotected network. Various software tools exist to automate this collection of information. For this reason, :term:`telnet` is rarely used today to access remote computers. It is usually replaced by :term:`ssh` or similar protocols.</source>
        <target state="translated">From a security viewpoint, the main drawback of :term:`telnet` is that all the information, including the usernames, passwords and commands, is sent in cleartext over a TCP connection. This implies that an eavesdropper could easily capture the passwords used by anyone on an unprotected network. Various software tools exist to automate this collection of information. For this reason, :term:`telnet` is rarely used today to access remote computers. It is usually replaced by :term:`ssh` or similar protocols.</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../protocols/ssh.rst</context>
          <context context-type="linenumber">28</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="e95621b099c377df" weblate-flags="read-only">
        <source>The secure shell (ssh)</source>
        <target state="translated">The secure shell (ssh)</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../protocols/ssh.rst</context>
          <context context-type="linenumber">40</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="c66b82f25d895a1d" weblate-flags="read-only">
        <source>The secure shell protocol was designed in the mid 1990s by T. Ylonen to counter the eavesdropping attacks against :term:`telnet` and similar protocols [Ylonen1996]_. :term:`ssh` became quickly popular and system administrators encouraged its usage. The original version of :term:`ssh` was freely available. After a few years, his author created a company to distribute it commercially, but other programmers continued to develop an open-source version of :term:`ssh` called `OpenSSH &lt;http://www.openssh.com&gt;`_. Over the years, :term:`ssh` evolved and became a flexible applicable whose usage extends beyond remote login to support features such as file transfers, protocol tunneling, ... In this section, we only discuss the basic features of :term:`ssh` and explain how it differs from :term:`telnet`. Entire books have been written to describe :term:`ssh` in details [BS2005]_. An overview of the protocol appeared in [Stallings2009]_.</source>
        <target state="translated">The secure shell protocol was designed in the mid 1990s by T. Ylonen to counter the eavesdropping attacks against :term:`telnet` and similar protocols [Ylonen1996]_. :term:`ssh` became quickly popular and system administrators encouraged its usage. The original version of :term:`ssh` was freely available. After a few years, his author created a company to distribute it commercially, but other programmers continued to develop an open-source version of :term:`ssh` called `OpenSSH &lt;http://www.openssh.com&gt;`_. Over the years, :term:`ssh` evolved and became a flexible applicable whose usage extends beyond remote login to support features such as file transfers, protocol tunneling, ... In this section, we only discuss the basic features of :term:`ssh` and explain how it differs from :term:`telnet`. Entire books have been written to describe :term:`ssh` in details [BS2005]_. An overview of the protocol appeared in [Stallings2009]_.</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../protocols/ssh.rst</context>
          <context context-type="linenumber">46</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="90867beeabeb370a" weblate-flags="read-only">
        <source>The :term:`ssh` protocol runs directly above the TCP protocol. Once the TCP bytestream has been established, the client and the server exchange messages. The first message exchanged is an ASCII line that announces the version of the protocol and the version of the software implementation used by the client and the server. These two lines are useful when debugging interoperability problems and other issues.</source>
        <target state="translated">The :term:`ssh` protocol runs directly above the TCP protocol. Once the TCP bytestream has been established, the client and the server exchange messages. The first message exchanged is an ASCII line that announces the version of the protocol and the version of the software implementation used by the client and the server. These two lines are useful when debugging interoperability problems and other issues.</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../protocols/ssh.rst</context>
          <context context-type="linenumber">62</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="9d9fafc20f77bc83" weblate-flags="read-only">
        <source>The next message is the ``SSH_MSG_KEX_INIT`` message that is used to negotiate the cryptographic algorithms that will be used for the ``ssh`` session. It is very important for security protocols to include mechanisms that enable a negotiation of the cryptographic algorithms that are used. First, these algorithms provide different levels of security. Some algorithms might be considered totally secure and are recommended today while they could become deprecated a few years later after the publication of some attacks. Second, these algorithms provide different levels of performance and have different CPU and memory impacts.</source>
        <target state="translated">The next message is the ``SSH_MSG_KEX_INIT`` message that is used to negotiate the cryptographic algorithms that will be used for the ``ssh`` session. It is very important for security protocols to include mechanisms that enable a negotiation of the cryptographic algorithms that are used. First, these algorithms provide different levels of security. Some algorithms might be considered totally secure and are recommended today while they could become deprecated a few years later after the publication of some attacks. Second, these algorithms provide different levels of performance and have different CPU and memory impacts.</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../protocols/ssh.rst</context>
          <context context-type="linenumber">70</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="b9dc476ec7210ca8" weblate-flags="read-only">
        <source>In practice, an ``ssh`` implementation supports four types of cryptographic algorithms :</source>
        <target state="translated">In practice, an ``ssh`` implementation supports four types of cryptographic algorithms :</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../protocols/ssh.rst</context>
          <context context-type="linenumber">81</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="b32b75a583fdf56c" weblate-flags="read-only">
        <source>key exchange</source>
        <target state="translated">key exchange</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../protocols/ssh.rst</context>
          <context context-type="linenumber">84</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="0e9bad9f16f186ca" weblate-flags="read-only">
        <source>encryption</source>
        <target state="translated">encryption</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../protocols/ssh.rst</context>
          <context context-type="linenumber">85</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="2e762381ad51a7bf" weblate-flags="read-only">
        <source>Message Authentication Code (MAC)</source>
        <target state="translated">Message Authentication Code (MAC)</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../protocols/ssh.rst</context>
          <context context-type="linenumber">86</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="aeb4e0470fa91758" weblate-flags="read-only">
        <source>compression</source>
        <target state="translated">compression</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../protocols/ssh.rst</context>
          <context context-type="linenumber">87</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="94e57c843b9dcb24" weblate-flags="read-only">
        <source>The IANA_ maintains a `list of the cryptographic algorithms &lt;http://www.iana.org/assignments/ssh-parameters/ssh-parameters.xhtml#ssh-parameters-16&gt;`_ that can be used by ``ssh`` implementations. For each type of algorithm, the client provides an ordered list of the algorithms that it supports and agrees to use. The server compares the received list with its own list. The outcome of the negotiation is a set of four algorithms [#fnull]_ that will be combined for this session.</source>
        <target state="translated">The IANA_ maintains a `list of the cryptographic algorithms &lt;http://www.iana.org/assignments/ssh-parameters/ssh-parameters.xhtml#ssh-parameters-16&gt;`_ that can be used by ``ssh`` implementations. For each type of algorithm, the client provides an ordered list of the algorithms that it supports and agrees to use. The server compares the received list with its own list. The outcome of the negotiation is a set of four algorithms [#fnull]_ that will be combined for this session.</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../protocols/ssh.rst</context>
          <context context-type="linenumber">89</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="ec52d89fa39d3d52" weblate-flags="read-only">
        <source>This negotiation of the cryptographic algorithms allows the implementations to evolve when new algorithms are proposed. If a client is upgraded, it can announce a new algorithm as its preferred one even if the server is not yet upgraded.</source>
        <target state="translated">This negotiation of the cryptographic algorithms allows the implementations to evolve when new algorithms are proposed. If a client is upgraded, it can announce a new algorithm as its preferred one even if the server is not yet upgraded.</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../protocols/ssh.rst</context>
          <context context-type="linenumber">121</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="bd01b20fe399cb8d" weblate-flags="read-only">
        <source>Once the cryptographic algorithms have been negotiated, the key exchange algorithm is used to negotiate a secret key that will be shared by the client and the server. These key exchange algorithms include some variations over the basic algorithms. As an example, let us analyze how the Diffie Hellman key exchange algorithm is used within the ``ssh`` protocol. In this case, each host has both a private and a public key.</source>
        <target state="translated">Once the cryptographic algorithms have been negotiated, the key exchange algorithm is used to negotiate a secret key that will be shared by the client and the server. These key exchange algorithms include some variations over the basic algorithms. As an example, let us analyze how the Diffie Hellman key exchange algorithm is used within the ``ssh`` protocol. In this case, each host has both a private and a public key.</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../protocols/ssh.rst</context>
          <context context-type="linenumber">131</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="8da1f8f8d8651666" weblate-flags="read-only">
        <source>the client generates the random number :math:`a` and sends :math:`A=g^{a} \mod p` to the server</source>
        <target state="translated">the client generates the random number :math:`a` and sends :math:`A=g^{a} \mod p` to the server</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../protocols/ssh.rst</context>
          <context context-type="linenumber">138</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="ce2cbd82fe6c1267" weblate-flags="read-only">
        <source>the server generates the random number :math:`b`. It then computes :math:`B=g^{b} \mod p`, :math:`K=B^{a} \mod p` and signs with its private key :math:`hash(V_{Client} || V_{Server} || KEX\_INIT_{Client} || KEX\_INIT_{Server} || Server_{pub} || A || B || K )` where :math:`V_{Server}` (resp. :math:`V_{Client}`) is the initial messages sent by the client (resp. server), :math:`KEX\_INIT_{Client}` (resp.  :math:`KEX\_INIT_{Server}`) is the key exchange message sent by the client (resp. server) and :math:`A`, :math:`B` and :math:`K` are the messages of the Diffie Hellman key exchange</source>
        <target state="translated">the server generates the random number :math:`b`. It then computes :math:`B=g^{b} \mod p`, :math:`K=B^{a} \mod p` and signs with its private key :math:`hash(V_{Client} || V_{Server} || KEX\_INIT_{Client} || KEX\_INIT_{Server} || Server_{pub} || A || B || K )` where :math:`V_{Server}` (resp. :math:`V_{Client}`) is the initial messages sent by the client (resp. server), :math:`KEX\_INIT_{Client}` (resp.  :math:`KEX\_INIT_{Server}`) is the key exchange message sent by the client (resp. server) and :math:`A`, :math:`B` and :math:`K` are the messages of the Diffie Hellman key exchange</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../protocols/ssh.rst</context>
          <context context-type="linenumber">140</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="ffb13018d2be0122" weblate-flags="read-only">
        <source>the client can recompute :math:`K=A^{b} \mod p` and verify the signature provided by the server</source>
        <target state="translated">the client can recompute :math:`K=A^{b} \mod p` and verify the signature provided by the server</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../protocols/ssh.rst</context>
          <context context-type="linenumber">148</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="143845ed1e578248" weblate-flags="read-only">
        <source>This is a slightly modified authenticated Diffie Hellman key exchange with two interesting points. The first point is that when the server authenticates the key exchange it does not provide a certificate. This is because ``ssh`` assumes that the client will store inside its cache the public key of the servers that it uses on a regular basis. This assumption is valid for a protocol like ``ssh`` because users typically use it to interact with a small number of servers, typically a few or a few tens. Storing this information does not require a lot of storage. In practice, most ``ssh`` clients will accept to connect to remote servers without knowing their public key before the connection. In this case, the client issues a warning to the user who can decide to accept or reject the key. This warning can be associated with a fingerprint of the key, either as a sequence of letters or as an ASCII art which can be posted on the web or elsewhere [#fdnsssh]_ by the system administrator of the server. If a client connects to a server whose public key does not match the stored one, a stronger warning is issued because this could indicate a man-in-the-middle attack or that the remote server has been compromised. It can also indicate that the server has been upgraded and that a new key has been generated during this upgrade.</source>
        <target state="translated">This is a slightly modified authenticated Diffie Hellman key exchange with two interesting points. The first point is that when the server authenticates the key exchange it does not provide a certificate. This is because ``ssh`` assumes that the client will store inside its cache the public key of the servers that it uses on a regular basis. This assumption is valid for a protocol like ``ssh`` because users typically use it to interact with a small number of servers, typically a few or a few tens. Storing this information does not require a lot of storage. In practice, most ``ssh`` clients will accept to connect to remote servers without knowing their public key before the connection. In this case, the client issues a warning to the user who can decide to accept or reject the key. This warning can be associated with a fingerprint of the key, either as a sequence of letters or as an ASCII art which can be posted on the web or elsewhere [#fdnsssh]_ by the system administrator of the server. If a client connects to a server whose public key does not match the stored one, a stronger warning is issued because this could indicate a man-in-the-middle attack or that the remote server has been compromised. It can also indicate that the server has been upgraded and that a new key has been generated during this upgrade.</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../protocols/ssh.rst</context>
          <context context-type="linenumber">151</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="c03181b7de64807a" weblate-flags="read-only">
        <source>The second point is that the server authenticates not only the result of the Diffie Hellman exchange but also a hash of all the information sent and received during the exchange. This is important to prevent `downgrade attacks`. A `downgrade attack` is an attack where an active attacker modifies the messages sent by the communicating hosts (typically the client) to request the utilization of weaker encryption algorithms. Consider a client that supports two encryption schemes. The preferred one uses 128 bits secret keys and the second one is an old encryption scheme that uses 48 bits keys. This second algorithm is kept for backward compatibility with older implementations. If an attacker can remove the preferred algorithm from the list of encryption algorithms supported by the client, he can force the server to use a weaker encryption scheme that will be easier to break. Thanks to the hash that covers all the messages exchanged by the server, the downgrade attack cannot occur against ``ssh``. Algorithm agility is a key requirement for security protocols that need to evolve when encryption algorithms are broken by researchers. This agility cannot be used without care and signing a hash of all the messages exchanged is a technique that is frequently used to prevent downgrade attacks.</source>
        <target state="translated">The second point is that the server authenticates not only the result of the Diffie Hellman exchange but also a hash of all the information sent and received during the exchange. This is important to prevent `downgrade attacks`. A `downgrade attack` is an attack where an active attacker modifies the messages sent by the communicating hosts (typically the client) to request the utilization of weaker encryption algorithms. Consider a client that supports two encryption schemes. The preferred one uses 128 bits secret keys and the second one is an old encryption scheme that uses 48 bits keys. This second algorithm is kept for backward compatibility with older implementations. If an attacker can remove the preferred algorithm from the list of encryption algorithms supported by the client, he can force the server to use a weaker encryption scheme that will be easier to break. Thanks to the hash that covers all the messages exchanged by the server, the downgrade attack cannot occur against ``ssh``. Algorithm agility is a key requirement for security protocols that need to evolve when encryption algorithms are broken by researchers. This agility cannot be used without care and signing a hash of all the messages exchanged is a technique that is frequently used to prevent downgrade attacks.</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../protocols/ssh.rst</context>
          <context context-type="linenumber">173</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="27e5a70442f4a3f6" weblate-flags="read-only">
        <source>Single use keys</source>
        <target state="translated">Single use keys</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../protocols/ssh.rst</context>
          <context context-type="linenumber">193</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="6a942c874d744b7f" weblate-flags="read-only">
        <source>Thanks to the Diffie Hellman key exchange, the client and the servers share key :math:`K`. A naive implementation would probably directly use this key for all the cryptographic algorithms that have been negotiated for this session. Like most security protocols, ``ssh`` does not directly use key :math:`K`. Instead, it uses the negotiated hash function with different parameters [#fsshkeys]_ to allow the client and the servers to compute six keys from :math:`K` :</source>
        <target state="translated">Thanks to the Diffie Hellman key exchange, the client and the servers share key :math:`K`. A naive implementation would probably directly use this key for all the cryptographic algorithms that have been negotiated for this session. Like most security protocols, ``ssh`` does not directly use key :math:`K`. Instead, it uses the negotiated hash function with different parameters [#fsshkeys]_ to allow the client and the servers to compute six keys from :math:`K` :</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../protocols/ssh.rst</context>
          <context context-type="linenumber">195</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="f382b36e300dc131" weblate-flags="read-only">
        <source>a key used by the client (resp. server) to encrypt the data that it sends</source>
        <target state="translated">a key used by the client (resp. server) to encrypt the data that it sends</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../protocols/ssh.rst</context>
          <context context-type="linenumber">204</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="2187d9896a01a93e" weblate-flags="read-only">
        <source>a key used by the client (resp. server) to authenticate the data that it sends</source>
        <target state="translated">a key used by the client (resp. server) to authenticate the data that it sends</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../protocols/ssh.rst</context>
          <context context-type="linenumber">206</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="b18bcfd1e068efd0" weblate-flags="read-only">
        <source>a key used by the client (resp. server) to initialize the negotiated encryption scheme (if required by this scheme)</source>
        <target state="translated">a key used by the client (resp. server) to initialize the negotiated encryption scheme (if required by this scheme)</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../protocols/ssh.rst</context>
          <context context-type="linenumber">208</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="b771f2b1fc22b87e" weblate-flags="read-only">
        <source>It is common practice among designers of security protocols to never use the same key for different purposes. For example, allowing the client and the server to use the same key to encrypt data could enable an attacker to launch a replay attack by sending to the client data that it has itself encrypted.</source>
        <target state="translated">It is common practice among designers of security protocols to never use the same key for different purposes. For example, allowing the client and the server to use the same key to encrypt data could enable an attacker to launch a replay attack by sending to the client data that it has itself encrypted.</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../protocols/ssh.rst</context>
          <context context-type="linenumber">211</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="4732a3d4599df1a9" weblate-flags="read-only">
        <source>At this point, all the messages sent over the TCP connection will be encrypted with the negotiated keys. The ``ssh`` protocol uses messages that are encoded according to the Binary Packet Protocol defined in :rfc:`4253`. Each of these messages contains the following information :</source>
        <target state="translated">At this point, all the messages sent over the TCP connection will be encrypted with the negotiated keys. The ``ssh`` protocol uses messages that are encoded according to the Binary Packet Protocol defined in :rfc:`4253`. Each of these messages contains the following information :</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../protocols/ssh.rst</context>
          <context context-type="linenumber">218</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="5d403a831697de1e" weblate-flags="read-only">
        <source>``length`` : this is the length of the message in bytes, excluding the MAC and length fields</source>
        <target state="translated">``length`` : this is the length of the message in bytes, excluding the MAC and length fields</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../protocols/ssh.rst</context>
          <context context-type="linenumber">223</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="ef7058f512806373" weblate-flags="read-only">
        <source>``padding length`` : this is the number of random bytes that have been added at the end of the message.</source>
        <target state="translated">``padding length`` : this is the number of random bytes that have been added at the end of the message.</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../protocols/ssh.rst</context>
          <context context-type="linenumber">225</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="44461d9e249f0269" weblate-flags="read-only">
        <source>``payload`` : the data (after optional compression) passed by the user</source>
        <target state="translated">``payload`` : the data (after optional compression) passed by the user</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../protocols/ssh.rst</context>
          <context context-type="linenumber">227</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="c5abc30e1809a4e4" weblate-flags="read-only">
        <source>``padding`` : random bytes added in each message (at least four) to ensure that the message length is a multiple of the block size used by the negotiated encryption algorithm</source>
        <target state="translated">``padding`` : random bytes added in each message (at least four) to ensure that the message length is a multiple of the block size used by the negotiated encryption algorithm</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../protocols/ssh.rst</context>
          <context context-type="linenumber">228</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="7780fd49313924fd" weblate-flags="read-only">
        <source>``MAC`` : this field is present if a Message Authentication Code has been negotiated for the session (in practice, using ``ssh`` without authentication is risky and this field should always be present). Note that to compute the MAC, an ``ssh`` implementation must maintain a message counter. This counter is incremented by one every time a message is sent and the MAC is computed with the negotiated authentication algorithm using the MAC key over the concatenation of the message counter and the cleartext message. The message counter is not transmitted, but the recipient can easily recover its value. The ``MAC`` is computed as :math:`mac = MAC(key, sequence\_number || unencrypted\_message)` where the key is the negotiated authentication key.</source>
        <target state="translated">``MAC`` : this field is present if a Message Authentication Code has been negotiated for the session (in practice, using ``ssh`` without authentication is risky and this field should always be present). Note that to compute the MAC, an ``ssh`` implementation must maintain a message counter. This counter is incremented by one every time a message is sent and the MAC is computed with the negotiated authentication algorithm using the MAC key over the concatenation of the message counter and the cleartext message. The message counter is not transmitted, but the recipient can easily recover its value. The ``MAC`` is computed as :math:`mac = MAC(key, sequence\_number || unencrypted\_message)` where the key is the negotiated authentication key.</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../protocols/ssh.rst</context>
          <context context-type="linenumber">231</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="3d135b6ec86a6b2c" weblate-flags="read-only">
        <source>Authenticating messages with HMAC</source>
        <target state="translated">Authenticating messages with HMAC</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../protocols/ssh.rst</context>
          <context context-type="linenumber">246</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="5ae1c3c4c8318dd0" weblate-flags="read-only">
        <source>`ssh` is one example of a protocol that uses Message Authentication Codes (MAC) to authenticates the messages that are sent. A naive implementation of such a MAC would be to simply use a hash function like SHA-1. However, such a construction would not be safe from a security viewpoint. Internet protocols usually rely on the HMAC construction defined in :rfc:`2104`. It works with any hash function (`H`) and a key (`K`). As an example, let us consider HMAC with the SHA-1 hash function. SHA-1 uses 20 bytes blocks and the block size will play an important role in the operation of HMAC. We first require the key to be as long as the block size. Since this key is the output of the key generation algorithm, this is one parameter of this algorithm.</source>
        <target state="translated">`ssh` is one example of a protocol that uses Message Authentication Codes (MAC) to authenticates the messages that are sent. A naive implementation of such a MAC would be to simply use a hash function like SHA-1. However, such a construction would not be safe from a security viewpoint. Internet protocols usually rely on the HMAC construction defined in :rfc:`2104`. It works with any hash function (`H`) and a key (`K`). As an example, let us consider HMAC with the SHA-1 hash function. SHA-1 uses 20 bytes blocks and the block size will play an important role in the operation of HMAC. We first require the key to be as long as the block size. Since this key is the output of the key generation algorithm, this is one parameter of this algorithm.</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../protocols/ssh.rst</context>
          <context context-type="linenumber">248</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="7882bc37873a62d0" weblate-flags="read-only">
        <source>HMAC uses two padding strings : `ipad` (resp. `opad`)  which is a string containing 20 times byte ``0x36`` (resp. byte ``0x5C``). The HMAC is then computed as :math:`H[K \oplus opad, H(K \oplus ipad, data) ]` where :math:`\oplus` denotes the bitwise XOR operation. This computation has been shown to be stronger than the naive :math:`H(K,data)` against some types of cryptographic attacks.</source>
        <target state="translated">HMAC uses two padding strings : `ipad` (resp. `opad`)  which is a string containing 20 times byte ``0x36`` (resp. byte ``0x5C``). The HMAC is then computed as :math:`H[K \oplus opad, H(K \oplus ipad, data) ]` where :math:`\oplus` denotes the bitwise XOR operation. This computation has been shown to be stronger than the naive :math:`H(K,data)` against some types of cryptographic attacks.</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../protocols/ssh.rst</context>
          <context context-type="linenumber">260</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="9b2330346c4af58e" weblate-flags="read-only">
        <source>Among the various features of the ``ssh`` protocol, it is interesting to mention how users are authenticated by the server. The ``ssh`` protocol supports the classical username/password authentication (but both the username and the password are transmitted over the secure encrypted channel). In addition, ``ssh`` supports two authentication mechanisms that rely on public keys. To use the first one, each user needs to generate his/her own public/private key pair and store the public key on the server. To be authenticated, the user needs to sign a message containing his/her public key by using his/her private key. The server can easily verify the validity of the signature since it already knows the user's public key. The second authentication scheme is designed for hosts that trust each other. Each host has a public/private key pair and stores the public keys of the other hosts that it trusts. This is typically used in environments such as university labs where each user could access any of the available computers. If Alice has logged on ``computer1`` and wants to execute a command on ``computer2``, she can create an ``ssh`` session on this computer and type (again) her password. With the host-based authentication scheme, ``computer1`` signs a message with its private key to confirm that it has already authenticated Alice. ``computer2`` would then accept Alice's session without asking her credentials.</source>
        <target state="translated">Among the various features of the ``ssh`` protocol, it is interesting to mention how users are authenticated by the server. The ``ssh`` protocol supports the classical username/password authentication (but both the username and the password are transmitted over the secure encrypted channel). In addition, ``ssh`` supports two authentication mechanisms that rely on public keys. To use the first one, each user needs to generate his/her own public/private key pair and store the public key on the server. To be authenticated, the user needs to sign a message containing his/her public key by using his/her private key. The server can easily verify the validity of the signature since it already knows the user's public key. The second authentication scheme is designed for hosts that trust each other. Each host has a public/private key pair and stores the public keys of the other hosts that it trusts. This is typically used in environments such as university labs where each user could access any of the available computers. If Alice has logged on ``computer1`` and wants to execute a command on ``computer2``, she can create an ``ssh`` session on this computer and type (again) her password. With the host-based authentication scheme, ``computer1`` signs a message with its private key to confirm that it has already authenticated Alice. ``computer2`` would then accept Alice's session without asking her credentials.</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../protocols/ssh.rst</context>
          <context context-type="linenumber">269</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="bd3f705104162a25" weblate-flags="read-only">
        <source>The ``ssh`` protocol includes other features that are beyond the scope of this book. Additional details may be found in [BS2005]_.</source>
        <target state="translated">The ``ssh`` protocol includes other features that are beyond the scope of this book. Additional details may be found in [BS2005]_.</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../protocols/ssh.rst</context>
          <context context-type="linenumber">290</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="c463aea6549199a2" weblate-flags="read-only">
        <source>Footnotes</source>
        <target state="translated">Footnotes</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../protocols/ssh.rst</context>
          <context context-type="linenumber">295</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="92703ee1680e112a" weblate-flags="read-only">
        <source>For some of the algorithms, it is possible to negotiate the utilization of no algorithm. This happens frequently for the compression algorithm that is not always used. For this, both the client and the server must announce ``null`` in their ordered list of supported algorithms.</source>
        <target state="translated">For some of the algorithms, it is possible to negotiate the utilization of no algorithm. This happens frequently for the compression algorithm that is not always used. For this, both the client and the server must announce ``null`` in their ordered list of supported algorithms.</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../protocols/ssh.rst</context>
          <context context-type="linenumber">296</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="393e082c84d40396" weblate-flags="read-only">
        <source>For example, :rfc:`4255` describes a DNS record that can be used to associate an ``ssh`` fingerprint to a DNS name.</source>
        <target state="translated">For example, :rfc:`4255` describes a DNS record that can be used to associate an ``ssh`` fingerprint to a DNS name.</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../protocols/ssh.rst</context>
          <context context-type="linenumber">302</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="fdb65d142081ab26" weblate-flags="read-only">
        <source>The exact algorithms used for the computation of these keys are defined in :rfc:`4253`</source>
        <target state="translated">The exact algorithms used for the computation of these keys are defined in :rfc:`4253`</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../protocols/ssh.rst</context>
          <context context-type="linenumber">305</context>
        </context-group>
      </trans-unit>
    </body>
  </file>
</xliff>
