The Geeky Way - DevOps, Linux//thegeekyway.com/2018-03-05T22:35:00+05:30Hands-on Guide on GPG Keys2018-03-05T22:35:00+05:302018-03-05T22:35:00+05:30GeekyShacklebolttag:thegeekyway.com,2018-03-05:/hands-on-guide-on-gpg-keys/<div style="text-align:center">
<p><img alt="" src="//thegeekyway.com/uploads/images/2018/03/GPG_guide.png"></p>
</div>
<p>GPG or GNU Privacy Guard is a complete and free implementation of the OpenPGP standard as defined by <a href="https://www.ietf.org/rfc/rfc4880.txt">RFC4880</a> (also known as PGP). It is a tool that provides encryption and signing services, using which, you can encrypt or sign your files, messages, emails and can even sign your github …</p><div style="text-align:center">
<p><img alt="" src="//thegeekyway.com/uploads/images/2018/03/GPG_guide.png"></p>
</div>
<p>GPG or GNU Privacy Guard is a complete and free implementation of the OpenPGP standard as defined by <a href="https://www.ietf.org/rfc/rfc4880.txt">RFC4880</a> (also known as PGP). It is a tool that provides encryption and signing services, using which, you can encrypt or sign your files, messages, emails and can even sign your github commits. In this guide, let's get a walk through GPG keys and its use cases.<!--more--></p>
<p>GPG is basically an implementation of a cryptosystem that you can use to exchange encrypted or signed messages and it is based on <a href="https://en.wikipedia.org/wiki/Public-key_cryptography">asymmetric cryptography</a>. It fulfills the <a href="http://whatis.techtarget.com/definition/Confidentiality-integrity-and-availability-CIA">CIA of security</a> where <strong>"C"</strong> stands for "Confidentiality", <strong>"I"</strong> stands for "Integrity" and <strong>"A"</strong> stands for "Availability".</p>
<h2>Before Generating a Key Pair</h2>
<p>In this tutorial, I am using <strong>"gpg2"</strong>, but you may go with <strong>"gpg"</strong> as well, because most of the commands are same for both. However, a comparison between both the versions is available at the end of this post.</p>
<p>To generate a key pair, first make sure you can run the following command.</p>
<div class="highlight"><pre><span></span><code>$<span class="w"> </span>gpg2<span class="w"> </span>--version
gpg<span class="w"> </span><span class="o">(</span>GnuPG<span class="o">)</span><span class="w"> </span><span class="m">2</span>.1.11
libgcrypt<span class="w"> </span><span class="m">1</span>.6.5
Copyright<span class="w"> </span><span class="o">(</span>C<span class="o">)</span><span class="w"> </span><span class="m">2016</span><span class="w"> </span>Free<span class="w"> </span>Software<span class="w"> </span>Foundation,<span class="w"> </span>Inc.
License<span class="w"> </span>GPLv3+:<span class="w"> </span>GNU<span class="w"> </span>GPL<span class="w"> </span>version<span class="w"> </span><span class="m">3</span><span class="w"> </span>or<span class="w"> </span>later<span class="w"> </span><http://gnu.org/licenses/gpl.html>
This<span class="w"> </span>is<span class="w"> </span>free<span class="w"> </span>software:<span class="w"> </span>you<span class="w"> </span>are<span class="w"> </span>free<span class="w"> </span>to<span class="w"> </span>change<span class="w"> </span>and<span class="w"> </span>redistribute<span class="w"> </span>it.
There<span class="w"> </span>is<span class="w"> </span>NO<span class="w"> </span>WARRANTY,<span class="w"> </span>to<span class="w"> </span>the<span class="w"> </span>extent<span class="w"> </span>permitted<span class="w"> </span>by<span class="w"> </span>law.
Home:<span class="w"> </span>~/.gnupg
Supported<span class="w"> </span>algorithms:
Pubkey:<span class="w"> </span>RSA,<span class="w"> </span>ELG,<span class="w"> </span>DSA,<span class="w"> </span>ECDH,<span class="w"> </span>ECDSA,<span class="w"> </span>EDDSA
Cipher:<span class="w"> </span>IDEA,<span class="w"> </span>3DES,<span class="w"> </span>CAST5,<span class="w"> </span>BLOWFISH,<span class="w"> </span>AES,<span class="w"> </span>AES192,<span class="w"> </span>AES256,<span class="w"> </span>TWOFISH,
<span class="w"> </span>CAMELLIA128,<span class="w"> </span>CAMELLIA192,<span class="w"> </span>CAMELLIA256
Hash:<span class="w"> </span>SHA1,<span class="w"> </span>RIPEMD160,<span class="w"> </span>SHA256,<span class="w"> </span>SHA384,<span class="w"> </span>SHA512,<span class="w"> </span>SHA224
Compression:<span class="w"> </span>Uncompressed,<span class="w"> </span>ZIP,<span class="w"> </span>ZLIB,<span class="w"> </span>BZIP2
</code></pre></div>
<p>It gives the version number of <strong>gpg</strong> like <strong>2.1.11</strong>. If not, then you need to install it, the package is <strong>gnupg</strong> (for gpg) or <strong>gnupg2</strong> (for gpg2).</p>
<div class="highlight"><pre><span></span><code>$<span class="w"> </span>sudo<span class="w"> </span>apt-get<span class="w"> </span>update
$<span class="w"> </span>sudo<span class="w"> </span>apt-get<span class="w"> </span>install<span class="w"> </span>gnupg2
</code></pre></div>
<h2>Generate a Key Pair</h2>
<p>Simply run the following command to generate a new key pair.</p>
<div class="highlight"><pre><span></span><code>$<span class="w"> </span>gpg2<span class="w"> </span>--full-gen-key
</code></pre></div>
<p>You may try this command with <strong>"sudo"</strong> if required.</p>
<p><strong>Note:- Either use "gpg", "gpg2", "sudo gpg" or "sudo gpg2". But whatever you use, keep that same.</strong> That means, if <strong>"sudo gpg2" </strong>worked for you, then keep it same for all the upcoming commands.</p>
<p>This command will ask you the following questions.</p>
<ul>
<li><strong><em>What kind of key do you want (RSA, DSA, etc)?</em></strong><br>
You should go with default selection.</li>
<li><strong><em>Key size?</em></strong><br>
The longer, the better.</li>
<li><strong><em>How long should the key be valid?</em></strong><br>
It is good to give here some value e.i <strong>"2y"</strong> (2 years) as it is suggested to all people that start with PGP to use an expiring key. Because at some point, you are likely to lose access to the private key, and then you can't revoke the key so that other people stop using it. But if it expires, everyone will stop using it at the expiration date.</li>
<li><strong><em>Your real name?</em></strong></li>
<li><strong><em>Your email address?</em></strong></li>
<li><strong><em>Any comment?</em></strong><br>
For now, you may leave the comment empty. But comments are used to distinctly identify a key, in case you have multiple GPG keys.</li>
<li><strong><em>Final confirmation (y/n)?</em></strong></li>
<li><strong><em>Your passphrase</em>?</strong><br>
Enter a strong passphrase twice and proceed ahead.</li>
</ul>
<p>At this point, <strong>GPG</strong> will generate the keys using entropy. <em>Entropy</em> describes the amount of unpredictability and nondeterminism that exists in a system. This entropy is needed to generate a secure set of keys. This process may take some time depending on how active your system is, and the key size you selected. The terminal may look like this.</p>
<div class="highlight"><pre><span></span><code>$<span class="w"> </span>gpg2<span class="w"> </span>--full-gen-key<span class="w"> </span>
gpg<span class="w"> </span><span class="o">(</span>GnuPG<span class="o">)</span><span class="w"> </span><span class="m">2</span>.1.11<span class="p">;</span><span class="w"> </span>Copyright<span class="w"> </span><span class="o">(</span>C<span class="o">)</span><span class="w"> </span><span class="m">2016</span><span class="w"> </span>Free<span class="w"> </span>Software<span class="w"> </span>Foundation,<span class="w"> </span>Inc.
This<span class="w"> </span>is<span class="w"> </span>free<span class="w"> </span>software:<span class="w"> </span>you<span class="w"> </span>are<span class="w"> </span>free<span class="w"> </span>to<span class="w"> </span>change<span class="w"> </span>and<span class="w"> </span>redistribute<span class="w"> </span>it.
There<span class="w"> </span>is<span class="w"> </span>NO<span class="w"> </span>WARRANTY,<span class="w"> </span>to<span class="w"> </span>the<span class="w"> </span>extent<span class="w"> </span>permitted<span class="w"> </span>by<span class="w"> </span>law.
Please<span class="w"> </span><span class="k">select</span><span class="w"> </span>what<span class="w"> </span>kind<span class="w"> </span>of<span class="w"> </span>key<span class="w"> </span>you<span class="w"> </span>want:
<span class="o">(</span><span class="m">1</span><span class="o">)</span><span class="w"> </span>RSA<span class="w"> </span>and<span class="w"> </span>RSA<span class="w"> </span><span class="o">(</span>default<span class="o">)</span>
<span class="o">(</span><span class="m">2</span><span class="o">)</span><span class="w"> </span>DSA<span class="w"> </span>and<span class="w"> </span>Elgamal
<span class="o">(</span><span class="m">3</span><span class="o">)</span><span class="w"> </span>DSA<span class="w"> </span><span class="o">(</span>sign<span class="w"> </span>only<span class="o">)</span>
<span class="o">(</span><span class="m">4</span><span class="o">)</span><span class="w"> </span>RSA<span class="w"> </span><span class="o">(</span>sign<span class="w"> </span>only<span class="o">)</span>
Your<span class="w"> </span>selection?<span class="w"> </span><span class="m">1</span>
RSA<span class="w"> </span>keys<span class="w"> </span>may<span class="w"> </span>be<span class="w"> </span>between<span class="w"> </span><span class="m">1024</span><span class="w"> </span>and<span class="w"> </span><span class="m">4096</span><span class="w"> </span>bits<span class="w"> </span>long.
What<span class="w"> </span>keysize<span class="w"> </span><span class="k">do</span><span class="w"> </span>you<span class="w"> </span>want?<span class="w"> </span><span class="o">(</span><span class="m">2048</span><span class="o">)</span><span class="w"> </span><span class="m">4096</span>
Requested<span class="w"> </span>keysize<span class="w"> </span>is<span class="w"> </span><span class="m">4096</span><span class="w"> </span>bits
Please<span class="w"> </span>specify<span class="w"> </span>how<span class="w"> </span>long<span class="w"> </span>the<span class="w"> </span>key<span class="w"> </span>should<span class="w"> </span>be<span class="w"> </span>valid.
<span class="nv">0</span><span class="w"> </span><span class="o">=</span><span class="w"> </span>key<span class="w"> </span>does<span class="w"> </span>not<span class="w"> </span>expire
<n><span class="w"> </span><span class="o">=</span><span class="w"> </span>key<span class="w"> </span>expires<span class="w"> </span><span class="k">in</span><span class="w"> </span>n<span class="w"> </span>days
<n>w<span class="w"> </span><span class="o">=</span><span class="w"> </span>key<span class="w"> </span>expires<span class="w"> </span><span class="k">in</span><span class="w"> </span>n<span class="w"> </span>weeks
<n>m<span class="w"> </span><span class="o">=</span><span class="w"> </span>key<span class="w"> </span>expires<span class="w"> </span><span class="k">in</span><span class="w"> </span>n<span class="w"> </span>months
<n>y<span class="w"> </span><span class="o">=</span><span class="w"> </span>key<span class="w"> </span>expires<span class="w"> </span><span class="k">in</span><span class="w"> </span>n<span class="w"> </span>years
Key<span class="w"> </span>is<span class="w"> </span>valid<span class="w"> </span><span class="k">for</span>?<span class="w"> </span><span class="o">(</span><span class="m">0</span><span class="o">)</span><span class="w"> </span>2y
Key<span class="w"> </span>expires<span class="w"> </span>at<span class="w"> </span>Tuesday<span class="w"> </span><span class="m">03</span><span class="w"> </span>March<span class="w"> </span><span class="m">2020</span><span class="w"> </span><span class="m">02</span>:08:15<span class="w"> </span>PM<span class="w"> </span>IST
Is<span class="w"> </span>this<span class="w"> </span>correct?<span class="w"> </span><span class="o">(</span>y/N<span class="o">)</span><span class="w"> </span>y
GnuPG<span class="w"> </span>needs<span class="w"> </span>to<span class="w"> </span>construct<span class="w"> </span>a<span class="w"> </span>user<span class="w"> </span>ID<span class="w"> </span>to<span class="w"> </span>identify<span class="w"> </span>your<span class="w"> </span>key.
Real<span class="w"> </span>name:<span class="w"> </span>Your<span class="w"> </span>Name
Email<span class="w"> </span>address:<span class="w"> </span>your.email@example.com
Comment:<span class="w"> </span>
You<span class="w"> </span>selected<span class="w"> </span>this<span class="w"> </span>USER-ID:
<span class="s2">"Your Name <your.email@example.com>"</span>
Change<span class="w"> </span><span class="o">(</span>N<span class="o">)</span>ame,<span class="w"> </span><span class="o">(</span>C<span class="o">)</span>omment,<span class="w"> </span><span class="o">(</span>E<span class="o">)</span>mail<span class="w"> </span>or<span class="w"> </span><span class="o">(</span>O<span class="o">)</span>kay/<span class="o">(</span>Q<span class="o">)</span>uit?<span class="w"> </span>O
We<span class="w"> </span>need<span class="w"> </span>to<span class="w"> </span>generate<span class="w"> </span>a<span class="w"> </span>lot<span class="w"> </span>of<span class="w"> </span>random<span class="w"> </span>bytes.<span class="w"> </span>It<span class="w"> </span>is<span class="w"> </span>a<span class="w"> </span>good<span class="w"> </span>idea<span class="w"> </span>to<span class="w"> </span>perform
some<span class="w"> </span>other<span class="w"> </span>action<span class="w"> </span><span class="o">(</span><span class="nb">type</span><span class="w"> </span>on<span class="w"> </span>the<span class="w"> </span>keyboard,<span class="w"> </span>move<span class="w"> </span>the<span class="w"> </span>mouse,<span class="w"> </span>utilize<span class="w"> </span>the
disks<span class="o">)</span><span class="w"> </span>during<span class="w"> </span>the<span class="w"> </span>prime<span class="w"> </span>generation<span class="p">;</span><span class="w"> </span>this<span class="w"> </span>gives<span class="w"> </span>the<span class="w"> </span>random<span class="w"> </span>number
generator<span class="w"> </span>a<span class="w"> </span>better<span class="w"> </span>chance<span class="w"> </span>to<span class="w"> </span>gain<span class="w"> </span>enough<span class="w"> </span>entropy.
</code></pre></div>
<h2>Generate an Authentication Subkey</h2>
<p>An authentication subkey is used if you want to use your GPG key for SSH authentication. To generate this, just follow these steps:</p>
<ul>
<li><strong>\$ gpg2 --expert --edit-key your_key_id</strong></li>
<li>Enter <strong>addkey</strong> (to select the operation)</li>
<li>Select the type of key (e.i select "<strong>8</strong>" for RSA)</li>
<li>Enter <strong>'S'</strong> to toggle signing to OFF.</li>
<li>Enter <strong>'E'</strong> to toggle encrypting to OFF.</li>
<li>Enter <strong>'A'</strong> to toggle authentication to ON.</li>
<li>Enter <strong>'Q'</strong> to quit.</li>
<li>Enter key size. (e.i <strong>4096</strong>)</li>
<li>Enter validity period. (e.i <strong>"2y"</strong>)</li>
<li>Confirm your entries.</li>
<li>Confirm creation.</li>
<li>Enter Passphrase twice.</li>
</ul>
<p>After some time your authentication subkey would be generated. Output of the process is shown below.</p>
<div class="highlight"><pre><span></span><code><span class="err">$</span><span class="w"> </span><span class="n">gpg2</span><span class="w"> </span><span class="o">--</span><span class="n">expert</span><span class="w"> </span><span class="o">--</span><span class="n">edit</span><span class="o">-</span><span class="k">key</span><span class="w"> </span><span class="mi">123</span><span class="n">EE456</span>
<span class="n">gpg</span><span class="w"> </span><span class="p">(</span><span class="n">GnuPG</span><span class="p">)</span><span class="w"> </span><span class="mf">2.1.11</span><span class="p">;</span><span class="w"> </span><span class="n">Copyright</span><span class="w"> </span><span class="p">(</span><span class="n">C</span><span class="p">)</span><span class="w"> </span><span class="mi">2016</span><span class="w"> </span><span class="k">Free</span><span class="w"> </span><span class="n">Software</span><span class="w"> </span><span class="n">Foundation</span><span class="p">,</span><span class="w"> </span><span class="n">Inc</span><span class="p">.</span>
<span class="n">This</span><span class="w"> </span><span class="k">is</span><span class="w"> </span><span class="k">free</span><span class="w"> </span><span class="nl">software</span><span class="p">:</span><span class="w"> </span><span class="n">you</span><span class="w"> </span><span class="k">are</span><span class="w"> </span><span class="k">free</span><span class="w"> </span><span class="k">to</span><span class="w"> </span><span class="n">change</span><span class="w"> </span><span class="ow">and</span><span class="w"> </span><span class="n">redistribute</span><span class="w"> </span><span class="n">it</span><span class="p">.</span>
<span class="n">There</span><span class="w"> </span><span class="k">is</span><span class="w"> </span><span class="k">NO</span><span class="w"> </span><span class="n">WARRANTY</span><span class="p">,</span><span class="w"> </span><span class="k">to</span><span class="w"> </span><span class="n">the</span><span class="w"> </span><span class="n">extent</span><span class="w"> </span><span class="n">permitted</span><span class="w"> </span><span class="k">by</span><span class="w"> </span><span class="n">law</span><span class="p">.</span>
<span class="n">Secret</span><span class="w"> </span><span class="k">key</span><span class="w"> </span><span class="k">is</span><span class="w"> </span><span class="n">available</span><span class="p">.</span>
<span class="n">sec</span><span class="w"> </span><span class="n">rsa4096</span><span class="o">/</span><span class="mi">123</span><span class="n">EE456</span>
<span class="w"> </span><span class="nl">created</span><span class="p">:</span><span class="w"> </span><span class="mi">2017</span><span class="o">-</span><span class="mi">04</span><span class="o">-</span><span class="mi">03</span><span class="w"> </span><span class="nl">expires</span><span class="p">:</span><span class="w"> </span><span class="mi">2019</span><span class="o">-</span><span class="mi">02</span><span class="o">-</span><span class="mi">02</span><span class="w"> </span><span class="k">usage</span><span class="err">:</span><span class="w"> </span><span class="n">SC</span><span class="w"> </span>
<span class="w"> </span><span class="nl">trust</span><span class="p">:</span><span class="w"> </span><span class="n">ultimate</span><span class="w"> </span><span class="nl">validity</span><span class="p">:</span><span class="w"> </span><span class="n">ultimate</span>
<span class="n">ssb</span><span class="w"> </span><span class="n">rsa4096</span><span class="o">/</span><span class="mi">7891</span><span class="n">EEFF</span>
<span class="w"> </span><span class="nl">created</span><span class="p">:</span><span class="w"> </span><span class="mi">2017</span><span class="o">-</span><span class="mi">04</span><span class="o">-</span><span class="mi">03</span><span class="w"> </span><span class="nl">expires</span><span class="p">:</span><span class="w"> </span><span class="mi">2019</span><span class="o">-</span><span class="mi">02</span><span class="o">-</span><span class="mi">02</span><span class="w"> </span><span class="k">usage</span><span class="err">:</span><span class="w"> </span><span class="n">E</span><span class="w"> </span>
<span class="o">[</span><span class="n">ultimate</span><span class="o">]</span><span class="w"> </span><span class="p">(</span><span class="mi">1</span><span class="p">).</span><span class="w"> </span><span class="nc">Real</span><span class="w"> </span><span class="n">Name</span><span class="w"> </span><span class="n">your</span><span class="p">.</span><span class="n">email</span><span class="nv">@gmail</span><span class="p">.</span><span class="n">com</span>
<span class="n">gpg</span><span class="o">></span><span class="w"> </span><span class="n">addkey</span>
<span class="n">Please</span><span class="w"> </span><span class="k">select</span><span class="w"> </span><span class="n">what</span><span class="w"> </span><span class="n">kind</span><span class="w"> </span><span class="k">of</span><span class="w"> </span><span class="k">key</span><span class="w"> </span><span class="n">you</span><span class="w"> </span><span class="nl">want</span><span class="p">:</span>
<span class="w"> </span><span class="p">(</span><span class="mi">3</span><span class="p">)</span><span class="w"> </span><span class="n">DSA</span><span class="w"> </span><span class="p">(</span><span class="nf">sign</span><span class="w"> </span><span class="k">only</span><span class="p">)</span>
<span class="w"> </span><span class="p">(</span><span class="mi">4</span><span class="p">)</span><span class="w"> </span><span class="n">RSA</span><span class="w"> </span><span class="p">(</span><span class="nf">sign</span><span class="w"> </span><span class="k">only</span><span class="p">)</span>
<span class="w"> </span><span class="p">(</span><span class="mi">5</span><span class="p">)</span><span class="w"> </span><span class="n">Elgamal</span><span class="w"> </span><span class="p">(</span><span class="n">encrypt</span><span class="w"> </span><span class="k">only</span><span class="p">)</span>
<span class="w"> </span><span class="p">(</span><span class="mi">6</span><span class="p">)</span><span class="w"> </span><span class="n">RSA</span><span class="w"> </span><span class="p">(</span><span class="n">encrypt</span><span class="w"> </span><span class="k">only</span><span class="p">)</span>
<span class="w"> </span><span class="p">(</span><span class="mi">7</span><span class="p">)</span><span class="w"> </span><span class="n">DSA</span><span class="w"> </span><span class="p">(</span><span class="k">set</span><span class="w"> </span><span class="n">your</span><span class="w"> </span><span class="n">own</span><span class="w"> </span><span class="n">capabilities</span><span class="p">)</span>
<span class="w"> </span><span class="p">(</span><span class="mi">8</span><span class="p">)</span><span class="w"> </span><span class="n">RSA</span><span class="w"> </span><span class="p">(</span><span class="k">set</span><span class="w"> </span><span class="n">your</span><span class="w"> </span><span class="n">own</span><span class="w"> </span><span class="n">capabilities</span><span class="p">)</span>
<span class="w"> </span><span class="p">(</span><span class="mi">10</span><span class="p">)</span><span class="w"> </span><span class="n">ECC</span><span class="w"> </span><span class="p">(</span><span class="nf">sign</span><span class="w"> </span><span class="k">only</span><span class="p">)</span>
<span class="w"> </span><span class="p">(</span><span class="mi">11</span><span class="p">)</span><span class="w"> </span><span class="n">ECC</span><span class="w"> </span><span class="p">(</span><span class="k">set</span><span class="w"> </span><span class="n">your</span><span class="w"> </span><span class="n">own</span><span class="w"> </span><span class="n">capabilities</span><span class="p">)</span>
<span class="w"> </span><span class="p">(</span><span class="mi">12</span><span class="p">)</span><span class="w"> </span><span class="n">ECC</span><span class="w"> </span><span class="p">(</span><span class="n">encrypt</span><span class="w"> </span><span class="k">only</span><span class="p">)</span>
<span class="w"> </span><span class="p">(</span><span class="mi">13</span><span class="p">)</span><span class="w"> </span><span class="n">Existing</span><span class="w"> </span><span class="k">key</span>
<span class="n">Your</span><span class="w"> </span><span class="n">selection</span><span class="vm">?</span><span class="w"> </span><span class="mi">8</span>
<span class="n">Possible</span><span class="w"> </span><span class="n">actions</span><span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="n">a</span><span class="w"> </span><span class="n">RSA</span><span class="w"> </span><span class="k">key</span><span class="err">:</span><span class="w"> </span><span class="nf">Sign</span><span class="w"> </span><span class="n">Encrypt</span><span class="w"> </span><span class="n">Authenticate</span><span class="w"> </span>
<span class="k">Current</span><span class="w"> </span><span class="n">allowed</span><span class="w"> </span><span class="nl">actions</span><span class="p">:</span><span class="w"> </span><span class="nf">Sign</span><span class="w"> </span><span class="n">Encrypt</span>
<span class="w"> </span><span class="p">(</span><span class="n">S</span><span class="p">)</span><span class="w"> </span><span class="n">Toggle</span><span class="w"> </span><span class="n">the</span><span class="w"> </span><span class="nf">sign</span><span class="w"> </span><span class="n">capability</span>
<span class="w"> </span><span class="p">(</span><span class="n">E</span><span class="p">)</span><span class="w"> </span><span class="n">Toggle</span><span class="w"> </span><span class="n">the</span><span class="w"> </span><span class="n">encrypt</span><span class="w"> </span><span class="n">capability</span>
<span class="w"> </span><span class="p">(</span><span class="n">A</span><span class="p">)</span><span class="w"> </span><span class="n">Toggle</span><span class="w"> </span><span class="n">the</span><span class="w"> </span><span class="n">authenticate</span><span class="w"> </span><span class="n">capability</span>
<span class="w"> </span><span class="p">(</span><span class="n">Q</span><span class="p">)</span><span class="w"> </span><span class="n">Finished</span>
<span class="n">Your</span><span class="w"> </span><span class="n">selection</span><span class="vm">?</span><span class="w"> </span><span class="n">S</span>
<span class="n">Possible</span><span class="w"> </span><span class="n">actions</span><span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="n">a</span><span class="w"> </span><span class="n">RSA</span><span class="w"> </span><span class="k">key</span><span class="err">:</span><span class="w"> </span><span class="nf">Sign</span><span class="w"> </span><span class="n">Encrypt</span><span class="w"> </span><span class="n">Authenticate</span><span class="w"> </span>
<span class="k">Current</span><span class="w"> </span><span class="n">allowed</span><span class="w"> </span><span class="nl">actions</span><span class="p">:</span><span class="w"> </span><span class="n">Encrypt</span>
<span class="p">(</span><span class="n">S</span><span class="p">)</span><span class="w"> </span><span class="n">Toggle</span><span class="w"> </span><span class="n">the</span><span class="w"> </span><span class="nf">sign</span><span class="w"> </span><span class="n">capability</span>
<span class="w"> </span><span class="p">(</span><span class="n">E</span><span class="p">)</span><span class="w"> </span><span class="n">Toggle</span><span class="w"> </span><span class="n">the</span><span class="w"> </span><span class="n">encrypt</span><span class="w"> </span><span class="n">capability</span>
<span class="w"> </span><span class="p">(</span><span class="n">A</span><span class="p">)</span><span class="w"> </span><span class="n">Toggle</span><span class="w"> </span><span class="n">the</span><span class="w"> </span><span class="n">authenticate</span><span class="w"> </span><span class="n">capability</span>
<span class="w"> </span><span class="p">(</span><span class="n">Q</span><span class="p">)</span><span class="w"> </span><span class="n">Finished</span>
<span class="n">Your</span><span class="w"> </span><span class="n">selection</span><span class="vm">?</span><span class="w"> </span><span class="n">E</span>
<span class="n">Possible</span><span class="w"> </span><span class="n">actions</span><span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="n">a</span><span class="w"> </span><span class="n">RSA</span><span class="w"> </span><span class="k">key</span><span class="err">:</span><span class="w"> </span><span class="nf">Sign</span><span class="w"> </span><span class="n">Encrypt</span><span class="w"> </span><span class="n">Authenticate</span><span class="w"> </span>
<span class="k">Current</span><span class="w"> </span><span class="n">allowed</span><span class="w"> </span><span class="nl">actions</span><span class="p">:</span>
<span class="p">(</span><span class="n">S</span><span class="p">)</span><span class="w"> </span><span class="n">Toggle</span><span class="w"> </span><span class="n">the</span><span class="w"> </span><span class="nf">sign</span><span class="w"> </span><span class="n">capability</span>
<span class="w"> </span><span class="p">(</span><span class="n">E</span><span class="p">)</span><span class="w"> </span><span class="n">Toggle</span><span class="w"> </span><span class="n">the</span><span class="w"> </span><span class="n">encrypt</span><span class="w"> </span><span class="n">capability</span>
<span class="w"> </span><span class="p">(</span><span class="n">A</span><span class="p">)</span><span class="w"> </span><span class="n">Toggle</span><span class="w"> </span><span class="n">the</span><span class="w"> </span><span class="n">authenticate</span><span class="w"> </span><span class="n">capability</span>
<span class="w"> </span><span class="p">(</span><span class="n">Q</span><span class="p">)</span><span class="w"> </span><span class="n">Finished</span>
<span class="n">Your</span><span class="w"> </span><span class="n">selection</span><span class="vm">?</span><span class="w"> </span><span class="n">A</span>
<span class="n">Possible</span><span class="w"> </span><span class="n">actions</span><span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="n">a</span><span class="w"> </span><span class="n">RSA</span><span class="w"> </span><span class="k">key</span><span class="err">:</span><span class="w"> </span><span class="nf">Sign</span><span class="w"> </span><span class="n">Encrypt</span><span class="w"> </span><span class="n">Authenticate</span><span class="w"> </span>
<span class="k">Current</span><span class="w"> </span><span class="n">allowed</span><span class="w"> </span><span class="nl">actions</span><span class="p">:</span><span class="w"> </span><span class="n">Authenticate</span>
<span class="p">(</span><span class="n">S</span><span class="p">)</span><span class="w"> </span><span class="n">Toggle</span><span class="w"> </span><span class="n">the</span><span class="w"> </span><span class="nf">sign</span><span class="w"> </span><span class="n">capability</span>
<span class="w"> </span><span class="p">(</span><span class="n">E</span><span class="p">)</span><span class="w"> </span><span class="n">Toggle</span><span class="w"> </span><span class="n">the</span><span class="w"> </span><span class="n">encrypt</span><span class="w"> </span><span class="n">capability</span>
<span class="w"> </span><span class="p">(</span><span class="n">A</span><span class="p">)</span><span class="w"> </span><span class="n">Toggle</span><span class="w"> </span><span class="n">the</span><span class="w"> </span><span class="n">authenticate</span><span class="w"> </span><span class="n">capability</span>
<span class="w"> </span><span class="p">(</span><span class="n">Q</span><span class="p">)</span><span class="w"> </span><span class="n">Finished</span>
<span class="n">Your</span><span class="w"> </span><span class="n">selection</span><span class="vm">?</span><span class="w"> </span><span class="n">Q</span>
<span class="n">RSA</span><span class="w"> </span><span class="n">keys</span><span class="w"> </span><span class="n">may</span><span class="w"> </span><span class="n">be</span><span class="w"> </span><span class="ow">between</span><span class="w"> </span><span class="mi">1024</span><span class="w"> </span><span class="ow">and</span><span class="w"> </span><span class="mi">4096</span><span class="w"> </span><span class="n">bits</span><span class="w"> </span><span class="n">long</span><span class="p">.</span>
<span class="n">What</span><span class="w"> </span><span class="n">keysize</span><span class="w"> </span><span class="n">do</span><span class="w"> </span><span class="n">you</span><span class="w"> </span><span class="n">want</span><span class="vm">?</span><span class="w"> </span><span class="p">(</span><span class="mi">2048</span><span class="p">)</span><span class="w"> </span><span class="mi">4096</span>
<span class="n">Requested</span><span class="w"> </span><span class="n">keysize</span><span class="w"> </span><span class="k">is</span><span class="w"> </span><span class="mi">4096</span><span class="w"> </span><span class="n">bits</span>
<span class="n">Please</span><span class="w"> </span><span class="n">specify</span><span class="w"> </span><span class="n">how</span><span class="w"> </span><span class="n">long</span><span class="w"> </span><span class="n">the</span><span class="w"> </span><span class="k">key</span><span class="w"> </span><span class="n">should</span><span class="w"> </span><span class="n">be</span><span class="w"> </span><span class="n">valid</span><span class="p">.</span>
<span class="w"> </span><span class="mi">0</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">key</span><span class="w"> </span><span class="n">does</span><span class="w"> </span><span class="ow">not</span><span class="w"> </span><span class="n">expire</span>
<span class="w"> </span><span class="o"><</span><span class="n">n</span><span class="o">></span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">key</span><span class="w"> </span><span class="n">expires</span><span class="w"> </span><span class="ow">in</span><span class="w"> </span><span class="n">n</span><span class="w"> </span><span class="n">days</span>
<span class="w"> </span><span class="o"><</span><span class="n">n</span><span class="o">></span><span class="n">w</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">key</span><span class="w"> </span><span class="n">expires</span><span class="w"> </span><span class="ow">in</span><span class="w"> </span><span class="n">n</span><span class="w"> </span><span class="n">weeks</span>
<span class="w"> </span><span class="o"><</span><span class="n">n</span><span class="o">></span><span class="n">m</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">key</span><span class="w"> </span><span class="n">expires</span><span class="w"> </span><span class="ow">in</span><span class="w"> </span><span class="n">n</span><span class="w"> </span><span class="n">months</span>
<span class="w"> </span><span class="o"><</span><span class="n">n</span><span class="o">></span><span class="n">y</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">key</span><span class="w"> </span><span class="n">expires</span><span class="w"> </span><span class="ow">in</span><span class="w"> </span><span class="n">n</span><span class="w"> </span><span class="n">years</span>
<span class="k">Key</span><span class="w"> </span><span class="k">is</span><span class="w"> </span><span class="n">valid</span><span class="w"> </span><span class="k">for</span><span class="vm">?</span><span class="w"> </span><span class="p">(</span><span class="mi">0</span><span class="p">)</span><span class="w"> </span><span class="mi">2</span><span class="n">y</span>
<span class="k">Key</span><span class="w"> </span><span class="n">expires</span><span class="w"> </span><span class="k">at</span><span class="w"> </span><span class="n">Thursday</span><span class="w"> </span><span class="mi">05</span><span class="w"> </span><span class="n">March</span><span class="w"> </span><span class="mi">2020</span><span class="w"> </span><span class="mi">02</span><span class="err">:</span><span class="mi">30</span><span class="err">:</span><span class="mi">01</span><span class="w"> </span><span class="n">AM</span><span class="w"> </span><span class="n">IST</span>
<span class="k">Is</span><span class="w"> </span><span class="n">this</span><span class="w"> </span><span class="n">correct</span><span class="vm">?</span><span class="w"> </span><span class="p">(</span><span class="n">y</span><span class="o">/</span><span class="n">N</span><span class="p">)</span><span class="w"> </span><span class="n">y</span>
<span class="n">Really</span><span class="w"> </span><span class="k">create</span><span class="vm">?</span><span class="w"> </span><span class="p">(</span><span class="n">y</span><span class="o">/</span><span class="n">N</span><span class="p">)</span><span class="w"> </span><span class="n">y</span>
<span class="n">We</span><span class="w"> </span><span class="n">need</span><span class="w"> </span><span class="k">to</span><span class="w"> </span><span class="n">generate</span><span class="w"> </span><span class="n">a</span><span class="w"> </span><span class="n">lot</span><span class="w"> </span><span class="k">of</span><span class="w"> </span><span class="n">random</span><span class="w"> </span><span class="n">bytes</span><span class="p">.</span><span class="w"> </span><span class="n">It</span><span class="w"> </span><span class="k">is</span><span class="w"> </span><span class="n">a</span><span class="w"> </span><span class="n">good</span><span class="w"> </span><span class="n">idea</span><span class="w"> </span><span class="k">to</span><span class="w"> </span><span class="n">perform</span>
<span class="ow">some</span><span class="w"> </span><span class="n">other</span><span class="w"> </span><span class="k">action</span><span class="w"> </span><span class="p">(</span><span class="n">type</span><span class="w"> </span><span class="k">on</span><span class="w"> </span><span class="n">the</span><span class="w"> </span><span class="n">keyboard</span><span class="p">,</span><span class="w"> </span><span class="n">move</span><span class="w"> </span><span class="n">the</span><span class="w"> </span><span class="n">mouse</span><span class="p">,</span><span class="w"> </span><span class="n">utilize</span><span class="w"> </span><span class="n">the</span>
<span class="n">disks</span><span class="p">)</span><span class="w"> </span><span class="n">during</span><span class="w"> </span><span class="n">the</span><span class="w"> </span><span class="n">prime</span><span class="w"> </span><span class="n">generation</span><span class="p">;</span><span class="w"> </span><span class="n">this</span><span class="w"> </span><span class="n">gives</span><span class="w"> </span><span class="n">the</span><span class="w"> </span><span class="n">random</span><span class="w"> </span><span class="n">number</span>
<span class="n">generator</span><span class="w"> </span><span class="n">a</span><span class="w"> </span><span class="n">better</span><span class="w"> </span><span class="n">chance</span><span class="w"> </span><span class="k">to</span><span class="w"> </span><span class="n">gain</span><span class="w"> </span><span class="n">enough</span><span class="w"> </span><span class="n">entropy</span><span class="p">.</span>
<span class="n">sec</span><span class="w"> </span><span class="n">rsa4096</span><span class="o">/</span><span class="mi">123</span><span class="n">EE456</span>
<span class="w"> </span><span class="nl">created</span><span class="p">:</span><span class="w"> </span><span class="mi">2017</span><span class="o">-</span><span class="mi">04</span><span class="o">-</span><span class="mi">03</span><span class="w"> </span><span class="nl">expires</span><span class="p">:</span><span class="w"> </span><span class="mi">2019</span><span class="o">-</span><span class="mi">02</span><span class="o">-</span><span class="mi">02</span><span class="w"> </span><span class="k">usage</span><span class="err">:</span><span class="w"> </span><span class="n">SC</span><span class="w"> </span>
<span class="w"> </span><span class="nl">trust</span><span class="p">:</span><span class="w"> </span><span class="n">ultimate</span><span class="w"> </span><span class="nl">validity</span><span class="p">:</span><span class="w"> </span><span class="n">ultimate</span>
<span class="n">ssb</span><span class="w"> </span><span class="n">rsa4096</span><span class="o">/</span><span class="mi">7891</span><span class="n">EEFF</span>
<span class="w"> </span><span class="nl">created</span><span class="p">:</span><span class="w"> </span><span class="mi">2017</span><span class="o">-</span><span class="mi">04</span><span class="o">-</span><span class="mi">03</span><span class="w"> </span><span class="nl">expires</span><span class="p">:</span><span class="w"> </span><span class="mi">2019</span><span class="o">-</span><span class="mi">02</span><span class="o">-</span><span class="mi">02</span><span class="w"> </span><span class="k">usage</span><span class="err">:</span><span class="w"> </span><span class="n">E</span><span class="w"> </span>
<span class="n">ssb</span><span class="w"> </span><span class="n">rsa4096</span><span class="o">/</span><span class="mi">6</span><span class="n">A127E44</span>
<span class="w"> </span><span class="nl">created</span><span class="p">:</span><span class="w"> </span><span class="mi">2018</span><span class="o">-</span><span class="mi">03</span><span class="o">-</span><span class="mi">05</span><span class="w"> </span><span class="nl">expires</span><span class="p">:</span><span class="w"> </span><span class="mi">2020</span><span class="o">-</span><span class="mi">03</span><span class="o">-</span><span class="mi">04</span><span class="w"> </span><span class="k">usage</span><span class="err">:</span><span class="w"> </span><span class="n">A</span>
</code></pre></div>
<p>Last 2 lines of the output show newly created authentication [A] subkey.</p>
<h2>List Keys</h2>
<p>To list all the public GPG keys. Give the following command.</p>
<div class="highlight"><pre><span></span><code>$<span class="w"> </span>gpg2<span class="w"> </span>--list-keys
</code></pre></div>
<p>To obtain the key id in LONG (complete) format, use this flag <strong>"--keyid-format LONG".</strong></p>
<div class="highlight"><pre><span></span><code>$<span class="w"> </span>gpg2<span class="w"> </span>--list-keys<span class="w"> </span>--keyid-format<span class="w"> </span>LONG
</code></pre></div>
<p>To list all the private GPG keys.</p>
<div class="highlight"><pre><span></span><code>$<span class="w"> </span>gpg2<span class="w"> </span>--list-secret-keys
</code></pre></div>
<p>All these commands give you the following information about your GPG keys and subkeys.</p>
<ul>
<li>Which algorithm your keys use, e.i <strong>rsa.</strong></li>
<li>Key size, e.i <strong>4096 bits.<br>
</strong></li>
<li>Key IDs, e.i <strong>123AB456</strong> (this is the short key id of 8-bytes, in the long format you get the complete key id of 16-bytes).</li>
<li>Date of creation.</li>
<li>Their usage e.i <p .st><strong>'E'</strong>=encryption, <strong>'S'</strong>=signing, <strong>'C'</strong>=certification, <strong>'A'</strong>=authentication.</p></li>
<li>Their expiry date.</li>
<li>Their trust level, e.i <strong>Ultimate, unknown, etc.</strong></li>
<li>Name and Email associated with them that's also known as <strong>UID</strong> "User ID".</li>
</ul>
<h2>Exporting Keys</h2>
<p>Exporting means, to bring out the keys from GPG database so that we may see or store them in files.</p>
<p>If you want to see your GPG key in ASCII characters, then you need to export it to a file by the following command.</p>
<div class="highlight"><pre><span></span><code>$<span class="w"> </span>gpg2<span class="w"> </span>--output<span class="w"> </span>public.key<span class="w"> </span>--armor<span class="w"> </span>--export<span class="w"> </span>your.email@example.com
</code></pre></div>
<p><strong>--output:</strong> specifies the output file.<br>
<strong>--export:</strong> to instruct GPG to export your public key.<br>
<strong>--armor:</strong> to export in ASCII characters.</p>
<p>Similarly, to export a private key directly on the terminal just change one flag.</p>
<div class="highlight"><pre><span></span><code>$<span class="w"> </span>gpg2<span class="w"> </span>--armor<span class="w"> </span>--export-secret-keys<span class="w"> </span>your.email@example.com
</code></pre></div>
<p>This will ask for your passphrase. Here you may also add the <strong>--output</strong> flag to put its output in a file as done in the previous command.</p>
<p><strong>Note: Never give/share your private key anywhere. Keep it as secure as you can.</strong> The private key is required to decrypt the data encrypted just for you. So, compromising this key may result in security issues whose severity depends on the data you deal with.</p>
<h2>Fingerprints</h2>
<p>A key can be verified by a number of ways. One such way is to use its fingerprint. The fingerprint is a shorter number (usually expressed as a 40-hexadecimal-digit number) that contains a cryptographically strong hash of the public key.</p>
<p>To see the fingerprint of any GPG key associated with an email. Use this command.</p>
<div class="highlight"><pre><span></span><code>$<span class="w"> </span>gpg2<span class="w"> </span>--fingerprint<span class="w"> </span>email@example.com
</code></pre></div>
<p>You can cross check this fingerprint with the person to verify if it is trustworthy.</p>
<p>Now when you have seen and understand your GPG keys. It's time to generate a revocation certificate.</p>
<h2>Generating a Revocation Certificate</h2>
<p>It is vital to have revocation certificate to declare your keys invalid in case your private key has been compromised or lost. It should be generated as soon as you generate your key pair, not when you need it. So, let's generate it with the following command.</p>
<div class="highlight"><pre><span></span><code>$<span class="w"> </span>gpg2<span class="w"> </span>--output<span class="w"> </span>~/revocation.crt<span class="w"> </span>--gen-revoke<span class="w"> </span>your.email@example.com
Please<span class="w"> </span><span class="k">select</span><span class="w"> </span>the<span class="w"> </span>reason<span class="w"> </span><span class="k">for</span><span class="w"> </span>the<span class="w"> </span>revocation:<span class="w"> </span>
<span class="w"> </span><span class="nv">0</span><span class="w"> </span><span class="o">=</span><span class="w"> </span>No<span class="w"> </span>reason<span class="w"> </span>specified
<span class="w"> </span><span class="nv">1</span><span class="w"> </span><span class="o">=</span><span class="w"> </span>Key<span class="w"> </span>has<span class="w"> </span>been<span class="w"> </span>compromised
<span class="w"> </span><span class="nv">2</span><span class="w"> </span><span class="o">=</span><span class="w"> </span>Key<span class="w"> </span>is<span class="w"> </span>superseded
<span class="w"> </span><span class="nv">3</span><span class="w"> </span><span class="o">=</span><span class="w"> </span>Key<span class="w"> </span>is<span class="w"> </span>no<span class="w"> </span>longer<span class="w"> </span>used
<span class="w"> </span><span class="nv">Q</span><span class="w"> </span><span class="o">=</span><span class="w"> </span>Cancel<span class="w"> </span>
<span class="o">(</span>Probably<span class="w"> </span>you<span class="w"> </span>want<span class="w"> </span>to<span class="w"> </span><span class="k">select</span><span class="w"> </span><span class="m">1</span><span class="w"> </span>here<span class="o">)</span><span class="w"> </span>
Your<span class="w"> </span>decision?<span class="w"> </span><span class="m">0</span>
</code></pre></div>
<p>It would ask for your confirmation for generating the certificate and the reason for which you are creating this. It is also suggested that you should have revocation certificates for every possibility listed there for maximum flexibility, but for now, you may go for <strong>"0: No reason specified"</strong>.</p>
<p>Now give a comment (I left it empty) and your passphrase. Soon, your certificate is generated. You should keep this as secure and hidden as you keep your private keys. Here is the output.</p>
<div class="highlight"><pre><span></span><code><span class="nt">Enter</span><span class="w"> </span><span class="nt">an</span><span class="w"> </span><span class="nt">optional</span><span class="w"> </span><span class="nt">description</span><span class="o">;</span><span class="w"> </span><span class="nt">end</span><span class="w"> </span><span class="nt">it</span><span class="w"> </span><span class="nt">with</span><span class="w"> </span><span class="nt">an</span><span class="w"> </span><span class="nt">empty</span><span class="w"> </span><span class="nt">line</span><span class="o">:</span>
<span class="o">></span><span class="w"> </span>
<span class="nt">Reason</span><span class="w"> </span><span class="nt">for</span><span class="w"> </span><span class="nt">revocation</span><span class="o">:</span><span class="w"> </span><span class="nt">No</span><span class="w"> </span><span class="nt">reason</span><span class="w"> </span><span class="nt">specified</span>
<span class="o">(</span><span class="nt">No</span><span class="w"> </span><span class="nt">description</span><span class="w"> </span><span class="nt">given</span><span class="o">)</span>
<span class="nt">Is</span><span class="w"> </span><span class="nt">this</span><span class="w"> </span><span class="nt">okay</span><span class="o">?</span><span class="w"> </span><span class="o">(</span><span class="nt">y</span><span class="o">/</span><span class="nt">N</span><span class="o">)</span><span class="w"> </span><span class="nt">y</span>
<span class="nt">ASCII</span><span class="w"> </span><span class="nt">armored</span><span class="w"> </span><span class="nt">output</span><span class="w"> </span><span class="nt">forced</span><span class="o">.</span>
<span class="nt">Revocation</span><span class="w"> </span><span class="nt">certificate</span><span class="w"> </span><span class="nt">created</span><span class="o">.</span>
<span class="nt">Please</span><span class="w"> </span><span class="nt">move</span><span class="w"> </span><span class="nt">it</span><span class="w"> </span><span class="nt">to</span><span class="w"> </span><span class="nt">a</span><span class="w"> </span><span class="nt">medium</span><span class="w"> </span><span class="nt">which</span><span class="w"> </span><span class="nt">you</span><span class="w"> </span><span class="nt">can</span><span class="w"> </span><span class="nt">hide</span><span class="w"> </span><span class="nt">away</span><span class="o">;</span><span class="w"> </span><span class="nt">if</span><span class="w"> </span><span class="nt">Mallory</span><span class="w"> </span><span class="nt">gets</span>
<span class="nt">access</span><span class="w"> </span><span class="nt">to</span><span class="w"> </span><span class="nt">this</span><span class="w"> </span><span class="nt">certificate</span><span class="w"> </span><span class="nt">he</span><span class="w"> </span><span class="nt">can</span><span class="w"> </span><span class="nt">use</span><span class="w"> </span><span class="nt">it</span><span class="w"> </span><span class="nt">to</span><span class="w"> </span><span class="nt">make</span><span class="w"> </span><span class="nt">your</span><span class="w"> </span><span class="nt">key</span><span class="w"> </span><span class="nt">unusable</span><span class="o">.</span>
<span class="nt">It</span><span class="w"> </span><span class="nt">is</span><span class="w"> </span><span class="nt">smart</span><span class="w"> </span><span class="nt">to</span><span class="w"> </span><span class="nt">print</span><span class="w"> </span><span class="nt">this</span><span class="w"> </span><span class="nt">certificate</span><span class="w"> </span><span class="nt">and</span><span class="w"> </span><span class="nt">store</span><span class="w"> </span><span class="nt">it</span><span class="w"> </span><span class="nt">away</span><span class="o">,</span><span class="w"> </span><span class="nt">just</span><span class="w"> </span><span class="nt">in</span><span class="w"> </span><span class="nt">case</span>
<span class="nt">your</span><span class="w"> </span><span class="nt">media</span><span class="w"> </span><span class="nt">become</span><span class="w"> </span><span class="nt">unreadable</span><span class="o">.</span><span class="w"> </span><span class="nt">But</span><span class="w"> </span><span class="nt">have</span><span class="w"> </span><span class="nt">some</span><span class="w"> </span><span class="nt">caution</span><span class="o">:</span><span class="w"> </span><span class="nt">The</span><span class="w"> </span><span class="nt">print</span><span class="w"> </span><span class="nt">system</span><span class="w"> </span><span class="nt">of</span>
<span class="nt">your</span><span class="w"> </span><span class="nt">machine</span><span class="w"> </span><span class="nt">might</span><span class="w"> </span><span class="nt">store</span><span class="w"> </span><span class="nt">the</span><span class="w"> </span><span class="nt">data</span><span class="w"> </span><span class="nt">and</span><span class="w"> </span><span class="nt">make</span><span class="w"> </span><span class="nt">it</span><span class="w"> </span><span class="nt">available</span><span class="w"> </span><span class="nt">to</span><span class="w"> </span><span class="nt">others</span><span class="o">!</span>
</code></pre></div>
<p>In order to save this file from unauthorized access, you may immediately put restrictions (if not present by default).</p>
<div class="highlight"><pre><span></span><code>$<span class="w"> </span>chmod<span class="w"> </span><span class="m">600</span><span class="w"> </span>~/revocation.crt
</code></pre></div>
<p>In case you want to revoke your key, then you would have to upload this revocation certificate to a public keyserver (assuming that you have already sent <em>your public key to a keyserver</em>. See below.)</p>
<h2>Sending and Importing Keys</h2>
<h4><strong>Sending:</strong></h4>
<p><strong><em>Why are you using GPG keys in the first place?</em></strong><br>
Because with GPG you can sign messages or other people can encrypt messages to you.</p>
<p>Therefore, to make your key publicly available might be of great help. So that, anyone can take your public key to encrypt messages to you. For this, we can send our public key to a keyserver.</p>
<p><strong><em>Would it be safe to upload your public key on keyservers?</em></strong><br>
Absolutely yes, as I have already mentioned before that GPG works on <a href="https://en.wikipedia.org/wiki/Public-key_cryptography">asymmetric cryptography</a>, therefore having your public key to someone doesn't make a threat to your security. Because it is practically impossible to generate a private key from a public key.</p>
<p>There are multiple keyservers available to hold public keys like, <strong><em><a href="https://keys.fedoraproject.org/">keys.fedoraproject.org</a>, <a href="http://keyserver.ubuntu.com/">keyserver.ubuntu.com, etc</a>.</em></strong><strong> </strong>and they regularly synchronize among themselves. So if you send your key on <em>keyserver.ubuntu.com, then</em> after some time, it would also be available at <em>keys.fedoraproject.org.</em></p>
<p>To send your key to the keyserver use the following command.</p>
<div class="highlight"><pre><span></span><code>$<span class="w"> </span>gpg2<span class="w"> </span>--send-keys<span class="w"> </span>--keyserver<span class="w"> </span>keyserver_url<span class="w"> </span>key_id
</code></pre></div>
<p>If you don't want to upload your key to a keyserver (in case your communication is limited to a group of people) then you can also send your public key to them through email.</p>
<h4><strong>Importing:</strong></h4>
<p>Importing means to include the key in your GPG database, so that you may use them in future. For example, if you wanna send your friends an encrypted message, which can be done with their public keys. Therefore, first, you would need to import their keys into your GPG system and then only you may use them for encryption.</p>
<p>You can import the key of someone from a file, with the following command. For this, you must have their public key in a file say <strong>"their_gpg.key"</strong>.</p>
<div class="highlight"><pre><span></span><code><span class="err">$</span> <span class="n">gpg2</span> <span class="o">--</span><span class="kn">import</span> <span class="nn">their_gpg.key</span>
</code></pre></div>
<p>Now when you would list-keys with "<strong>gpg2 --list-keys</strong>", this imported key will also be listed.</p>
<p>But if the person's key is available at a keyserver, then you can also directly pull their keys from there. Because keyservers distribute public keys to anyone who requests them. Once you have sent your key to a keyserver, others can request your key using the command.</p>
<div class="highlight"><pre><span></span><code>$<span class="w"> </span>gpg2<span class="w"> </span>--keyserver<span class="w"> </span>keyserver_url<span class="w"> </span>--recv-keys<span class="w"> </span>key_id
</code></pre></div>
<p>To refresh all your keys from a keyserver, to obtain new signatures, new UIDs and new key revocations, use this.</p>
<div class="highlight"><pre><span></span><code>$<span class="w"> </span>gpg2<span class="w"> </span>--refresh-keys
</code></pre></div>
<p><kbd>And to pull from specific servers, use this.</kbd></p>
<div class="highlight"><pre><span></span><code>$<span class="w"> </span>gpg2<span class="w"> </span>--keyserver<span class="w"> </span>keyserver_url<span class="w"> </span>--refresh-keys
</code></pre></div>
<p>You should do this regularly. But you may receive error messages if any of your keys cannot be found on the key server.</p>
<h2>Signing Keys</h2>
<p>A major benefit of GPG is that you can sign a file to prove that it is genuinely coming form you. Because signs are created using private keys and only the person who owns the GPG keys, have its private key (if not compromised or lost).</p>
<p>Your key is already signed by you when it was created. That you may verify with.</p>
<div class="highlight"><pre><span></span><code>$<span class="w"> </span>gpg2<span class="w"> </span>--list-sig<span class="w"> </span>your.email@example.com
</code></pre></div>
<p>In the output, the line after <strong>"sig"</strong> shows the <strong>UID</strong> of those people who have signed your key.</p>
<p>You can also sign keys of other people (assuming that you have already imported the key of that person). Signing a key means you verify that you trust the person, who they claim to be. If you sign a person's key then sending the signed key back to him/her is a good idea, otherwise, they won't be able to take advantage of your sign. For this, you have 2 methods.</p>
<p><strong>Method 1:</strong></p>
<div class="highlight"><pre><span></span><code>$<span class="w"> </span>gpg2<span class="w"> </span>--sign-key<span class="w"> </span>person.email@example.com
$<span class="w"> </span>gpg2<span class="w"> </span>--output<span class="w"> </span>~/signed.key<span class="w"> </span>--sign-key<span class="w"> </span>person.email@example.com
</code></pre></div>
<p>Then you can send this "<strong>signed.key</strong>" file to the person via mail.</p>
<p>Once that person receives your signed key, then s//he can update their own GPG database to include your signature.</p>
<div class="highlight"><pre><span></span><code><span class="err">$</span> <span class="n">gpg2</span> <span class="o">--</span><span class="kn">import</span> <span class="nn">signed.key</span>
</code></pre></div>
<p><strong>Method 2:</strong></p>
<div class="highlight"><pre><span></span><code>$<span class="w"> </span>gpg2<span class="w"> </span>--sign-key<span class="w"> </span>person.email@example.com
$<span class="w"> </span>gpg2<span class="w"> </span>--keyserver<span class="w"> </span>key_server<span class="w"> </span>--send-key<span class="w"> </span>person_keyid
</code></pre></div>
<p>This will directly upload your sign to the keyserver (assuming that the person has sent his key to a keyserver). So when next time that person would refresh his/her GPG database, your sign would be included.</p>
<p><strong><em>Why should you sign a person's key?</em><em><br>
</em>Because this can help other people decide whether to trust that person too or not. If someone trusts you, and they see that you've signed this person's key, they may be more likely to trust their identity too. There is a concept behind signing a key known as </strong><a href="https://en.wikipedia.org/wiki/Web_of_trust">Web of Trust</a>.** (see below)</p>
<h2>Trust Levels and Validity</h2>
<p>Trust levels is a medium by which we can inform GPG that how much we trust a UID of a person associated with a key.</p>
<p>There are following trust levels available</p>
<ul>
<li><strong>Unknown:</strong> This is the default level that is set on validity and trust.</li>
<li><strong>Undefined:</strong> This is explicitly defining trust level to be unknown. Means you would like to confirm it later on.</li>
<li><strong>Never:</strong> This indicates that you do not trust the UID of that key.</li>
<li><strong>Marginal:</strong> This means you have half trust on the UID of that key.</li>
<li><strong>Full:</strong> This means you fully trust that person.</li>
<li><strong>Ultimate:</strong> There is only one UID that is marked with <strong>Ultimate</strong> trust, and that is of yourself.</li>
</ul>
<p>More detail about trust-levels is available <a href="https://gpgtools.tenderapp.com/kb/faq/what-is-ownertrust-trust-levels-explained">here</a>.</p>
<p>You may check the <strong>trust</strong> and <strong>validity</strong> levels of any <strong>UID</strong> among the keys you have imported, with this command.</p>
<div class="highlight"><pre><span></span><code>$<span class="w"> </span>gpg2<span class="w"> </span>--edit-key<span class="w"> </span>email@example.com
gpg<span class="w"> </span><span class="o">(</span>GnuPG<span class="o">)</span><span class="w"> </span><span class="m">2</span>.1.11<span class="p">;</span><span class="w"> </span>Copyright<span class="w"> </span><span class="o">(</span>C<span class="o">)</span><span class="w"> </span><span class="m">2016</span><span class="w"> </span>Free<span class="w"> </span>Software<span class="w"> </span>Foundation,<span class="w"> </span>Inc.
This<span class="w"> </span>is<span class="w"> </span>free<span class="w"> </span>software:<span class="w"> </span>you<span class="w"> </span>are<span class="w"> </span>free<span class="w"> </span>to<span class="w"> </span>change<span class="w"> </span>and<span class="w"> </span>redistribute<span class="w"> </span>it.
There<span class="w"> </span>is<span class="w"> </span>NO<span class="w"> </span>WARRANTY,<span class="w"> </span>to<span class="w"> </span>the<span class="w"> </span>extent<span class="w"> </span>permitted<span class="w"> </span>by<span class="w"> </span>law.
pub<span class="w"> </span>rsa2048/4A5N1031
<span class="w"> </span>created:<span class="w"> </span><span class="m">2016</span>-10-10<span class="w"> </span>expires:<span class="w"> </span><span class="m">2018</span>-10-10<span class="w"> </span>usage:<span class="w"> </span>SC<span class="w"> </span>
<span class="w"> </span>trust:<span class="w"> </span>unknown<span class="w"> </span>validity:<span class="w"> </span>unknown
sub<span class="w"> </span>rsa2048/73E6DB92
<span class="w"> </span>created:<span class="w"> </span><span class="m">2016</span>-10-10<span class="w"> </span>expires:<span class="w"> </span><span class="m">2018</span>-10-10<span class="w"> </span>usage:<span class="w"> </span>E<span class="w"> </span>
<span class="o">[</span><span class="w"> </span>unknown<span class="w"> </span><span class="o">]</span><span class="w"> </span><span class="o">(</span><span class="m">1</span><span class="o">)</span>.<span class="w"> </span>Person<span class="w"> </span>Name<span class="w"> </span>email@example.com
gpg:<span class="w"> </span>Q
</code></pre></div>
<p>To modify <strong>trust</strong> of the key, enter "<strong>trust"</strong> instead of <strong>"Q"</strong> (in the last line of output). And you'll get a prompt like this.</p>
<div class="highlight"><pre><span></span><code><span class="nv">Please</span><span class="w"> </span><span class="nv">decide</span><span class="w"> </span><span class="nv">how</span><span class="w"> </span><span class="nv">far</span><span class="w"> </span><span class="nv">you</span><span class="w"> </span><span class="nv">trust</span><span class="w"> </span><span class="nv">this</span><span class="w"> </span><span class="nv">user</span><span class="w"> </span><span class="nv">to</span><span class="w"> </span><span class="nv">correctly</span><span class="w"> </span><span class="nv">verify</span><span class="w"> </span><span class="nv">other</span><span class="w"> </span><span class="nv">users</span><span class="err">' keys</span>
<span class="err">(by looking at passports, checking fingerprints from different sources, etc.)</span>
<span class="w"> </span><span class="mi">1</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nv">I</span><span class="w"> </span><span class="nv">don</span><span class="s1">'t know or won'</span><span class="nv">t</span><span class="w"> </span><span class="nv">say</span>
<span class="w"> </span><span class="mi">2</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nv">I</span><span class="w"> </span><span class="k">do</span><span class="w"> </span><span class="nv">NOT</span><span class="w"> </span><span class="nv">trust</span>
<span class="w"> </span><span class="mi">3</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nv">I</span><span class="w"> </span><span class="nv">trust</span><span class="w"> </span><span class="nv">marginally</span>
<span class="w"> </span><span class="mi">4</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nv">I</span><span class="w"> </span><span class="nv">trust</span><span class="w"> </span><span class="nv">fully</span>
<span class="w"> </span><span class="mi">5</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nv">I</span><span class="w"> </span><span class="nv">trust</span><span class="w"> </span><span class="nv">ultimately</span>
<span class="w"> </span><span class="nv">m</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nv">back</span><span class="w"> </span><span class="nv">to</span><span class="w"> </span><span class="nv">the</span><span class="w"> </span><span class="nv">main</span><span class="w"> </span><span class="nv">menu</span>
<span class="nv">Your</span><span class="w"> </span><span class="nv">decision</span>?<span class="w"> </span><span class="nv">m</span>
</code></pre></div>
<p>Enter your decision, and that trust level would be set for that key.</p>
<p><strong>Why do we have trust levels?</strong></p>
<p>To understand this, first, you must understand <strong>validity.</strong> When you sign a key, you say that the key is <strong>valid</strong>. But you sign a key if and only if you are sure, that the key belongs the person whose UID is attached to the key. This verification could be done by personally contacting that person and cross-checking the fingerprint of the key.</p>
<p>Isn't it a tedious task to every time contacting people just to confirm the fingerprint of their GPG key? Especially, in the case when you haven't met that person before. Therefore, we have something called <strong>"<a href="https://en.wikipedia.org/wiki/Web_of_trust">Web of Trust</a>".</strong></p>
<p>Suppose you trust "<strong>Mike</strong>" and <strong>"John"</strong> that they sign GPG keys of other people only after completely verifying a UID. Then giving following <strong>Trust-levels</strong> to them would affect your key as follows.</p>
<ul>
<li><strong>Unknown/Undefined</strong> to <strong>Mike:</strong> Keys signed by Mike won't be valid for you.</li>
<li><strong>Never</strong> to <strong>Mike:</strong> Same as above, but here you have explicitly given that you don't trust <strong>Mike.</strong></li>
<li><strong>Marginal</strong> to <strong>Mike:</strong> Keys signed by Mike will be marginally valid for you.</li>
<li><strong>Marginal</strong> to <strong>Mike</strong> and <strong>John:</strong> Keys signed by both Mike and John will be valid for you (if the marginal limit is set to 2, otherwise if the marginal limit is set to <strong>"n"</strong> then a key becomes valid if it is signed by <strong>"n"</strong> UIDs).</li>
<li><strong>Full</strong> to <strong>Mike:</strong> Keys signed by Mike will be valid for you as well.</li>
</ul>
<p>I recommend you to read <a href="https://www.gnupg.org/gph/en/manual/x334.html">this document</a> to get a better understanding of trust-levels and validity.</p>
<h2>Encryption-Decryption with GPG</h2>
<h4>Encrypting a file</h4>
<p>To encrypt and sign a file for a recipient you must have his/her public key imported.</p>
<div class="highlight"><pre><span></span><code>$<span class="w"> </span>gpg2<span class="w"> </span>-r<span class="w"> </span>email.of.recipient@example.com<span class="w"> </span>-r<span class="w"> </span>your.email@example.com<span class="w"> </span>--encrypt<span class="w"> </span>--sign<span class="w"> </span>--armor<span class="w"> </span>file_name
</code></pre></div>
<ul>
<li><strong>gpg2:</strong> command</li>
<li><strong>-r:</strong> to give email_address to possible recipients (who can decrypt this file).</li>
<li><strong>-r:</strong> adding yourself as one of the recipients so that you can also decrypt the file otherwise after encrypting, even you won't be able to decrypt it.</li>
<li><strong>--encrypt:</strong> instructing to encrypt.</li>
<li><strong>--sign:</strong> instructing to sign the file as well.</li>
<li><strong>--armor:</strong> to encrypt in ASCII characters.<strong> </strong></li>
<li><strong>file_name:</strong> complete path of the file, If you omit this part, then after giving this command, the terminal will wait for you to enter the text. When you are done with entering your message, press <strong>CTRL + d</strong> (Linux). It would generate the encrypted form of your message, which you may copy to clipboard and paste in any file.</li>
</ul>
<p>If you haven't set any trust level for that recipient, then you are likely to get here a confirmation prompt for using the recipient's public key for encryption. And finally, it would prompt you for your passphrase.</p>
<p>Soon an encrypted file would be created with <strong>.asc</strong> extension. But still, that unencrypted file is available. You are yourself responsible to delete the original file.</p>
<h4>Decrypting a file</h4>
<p>To decrypt a file that was encrypted by your public key just use.</p>
<div class="highlight"><pre><span></span><code>$<span class="w"> </span>gpg2<span class="w"> </span>file_name.asc
</code></pre></div>
<p>It would ask for your passphrase and a decrypted file would be available to you without "<strong>.asc"</strong> extension.</p>
<p>If the encrypted file was also <strong>signed</strong> by the sender, then the output of above command would also give information about signature like <strong><em>date_of_signature</em></strong> and <em><strong>status_of_signature</strong> (good or bad)</em> otherwise not.</p>
<h2>Signed messages</h2>
<h4><strong>Clearsign:</strong></h4>
<p>Using GPG you may send signed files without encryption. Create a file say "<strong>newfile</strong>", add some message to it and sign it.</p>
<div class="highlight"><pre><span></span><code>$<span class="w"> </span><span class="nb">echo</span><span class="w"> </span><span class="s2">"Hello World"</span><span class="w"> </span>>><span class="w"> </span>newfile
$<span class="w"> </span>gpg2<span class="w"> </span>--clearsign<span class="w"> </span>newfile
</code></pre></div>
<p><strong>--clearsign:</strong> wraps the message without encryption with your <strong>armored</strong> signature, so that any non-GPG user can read the message and any GPG user can verify it (if needed).</p>
<p>Soon "<strong>newfile.asc</strong>" would be created and anyone can verify, that it is signed by you.</p>
<div class="highlight"><pre><span></span><code>$<span class="w"> </span>gpg2<span class="w"> </span>--verify<span class="w"> </span>newfile
</code></pre></div>
<p>But it can give you warning of not having a detached signature.</p>
<div class="highlight"><pre><span></span><code><span class="n">gpg</span><span class="o">:</span><span class="w"> </span><span class="n">WARNING</span><span class="o">:</span><span class="w"> </span><span class="n">not</span><span class="w"> </span><span class="n">a</span><span class="w"> </span><span class="n">detached</span><span class="w"> </span><span class="n">signature</span><span class="o">;</span><span class="w"> </span><span class="n">file</span><span class="w"> </span><span class="s1">'newfile'</span><span class="w"> </span><span class="n">was</span><span class="w"> </span><span class="n">NOT</span><span class="w"> </span><span class="n">verified</span><span class="o">!</span>
</code></pre></div>
<p>(if yes, see below)</p>
<h4><strong>Detached signature:</strong></h4>
<p>Till now newfile<strong>.</strong>asc consisted both unencrypted message and signature in the same file. To solve this issue, we can sign a file with a detached signature so that the file and the signature can be kept separately.</p>
<div class="highlight"><pre><span></span><code>$<span class="w"> </span>gpg2<span class="w"> </span>--detach-sign<span class="w"> </span>newfile
</code></pre></div>
<p>Now a new file with name "<strong>newfile.sig</strong>" is created which contains just your signature. You may verify that with.</p>
<div class="highlight"><pre><span></span><code>$<span class="w"> </span>gpg2<span class="w"> </span>--verify<span class="w"> </span>newfile.sig
</code></pre></div>
<p>This will return verification statement and signature's information, together with the attached file's name. Now, if you change the file's (newfile) content and again check for verification, then it would fail. Because the new content wasn't signed by the signer. This way GPG maintains <strong>"Integrity"</strong>.</p>
<p>In case the signature verification failed, then understand that the content of the message has been modified in between.</p>
<h2>Integrated with GPG</h2>
<h4>Thunderbird</h4>
<p>You can use an email client like Thunderbird to automatically encrypt and sign your emails. For this, you would need to install an addon "<strong>Enigmail</strong>" in your Thunderbird and configure it. To configure Thunderbird proceed as follows.</p>
<ul>
<li>Open <strong>Thunderbird.</strong></li>
<li>From <strong>Menu Bar -> Tools -> Add-ons</strong>, install <strong>Enigmail.</strong></li>
<li>From <strong>Menu Bar -> Enigmail -> Setup Wizard</strong>, configure it.</li>
<li>Choose <strong>Standard Configuration</strong> then <strong>Next</strong>.</li>
<li>Now Select your GPG key and Complete the wizard.</li>
</ul>
<p>Now whenever you would send any mail to the email ID that you have already imported in GPG, your Thunderbird will itself encrypt it. You may explore more configuration options at <strong>Menu Bar -> Enigmail.</strong></p>
<h4>Github and Git</h4>
<p>You can add your GPG key to your <strong>GitHub profile</strong> and can configure your <strong>Git</strong> to sign your commits. Follow these steps or refer <a href="https://help.github.com/articles/signing-commits-with-gpg/">this</a>.</p>
<p><strong>To add your key to Github:</strong></p>
<ul>
<li>Login to your <strong>Github</strong> account.</li>
<li>At upper-right corner, click your profile photo and select <strong>Settings.</strong></li>
<li>From left panel select <strong>SSH and GPG keys</strong>.</li>
<li>Click on <strong>New GPG key</strong> button.</li>
<li>Paste your <strong>GPG public key</strong> there.<br>
You can export your GPG public key to your terminal with<br>
<strong>\$ gpg2 --armor --export<br>
</strong>Select your complete GPG public key and <strong>CTRL + SHIFT + C</strong> to copy.</li>
</ul>
<p><strong>To configure git with GPG key:</strong></p>
<ul>
<li><strong>\$ gpg2 --list-keys --keyid-format LONG</strong></li>
<li>Copy your complete key ID.</li>
<li><strong>\$ git config --global user.signingkey your_key_id</strong></li>
</ul>
<p>Now to sign your commits you may use <strong>-S</strong> flag in your <strong>git commit</strong> command.</p>
<div class="highlight"><pre><span></span><code>$<span class="w"> </span>git<span class="w"> </span>commit<span class="w"> </span>-S<span class="w"> </span>-m<span class="w"> </span><span class="s2">"commit message"</span>
</code></pre></div>
<p>You will be prompted to enter your passphrase while making commits.</p>
<h2>A Brief Comparison of GPG and GPG2</h2>
<ul>
<li>GPG2 is extended version of GPG. Where changes are mostly in internal levels, thus commands are same.</li>
<li>A major change between GPG and GPG2 is that all the crypto operations have been moved to the GPG agent, so without an agent, GPG2 can't work.</li>
<li><strong>man gpg2 </strong>command gives the following statement <em>"In contrast to the standalone version gpg, which is more suited for server and embedded platforms, this version is commonly installed under the name gpg2 and more targeted to the desktop as it requires several other modules to be installed."</em></li>
<li>An important change came with GPG 2.1, which combines the formerly separated public and private keyrings (pubring.gpg and secring.gpg) into the public keyring.</li>
<li>Explore more about what's new in GPG2 <a href="https://www.gnupg.org/faq/whats-new-in-2.1.html">here</a>.</li>
</ul>
<h2>Conclusion</h2>
<p>GPG is a recommended tool if you don't want to compromise security in your communication with people over an unsecured network like our Internet.</p>
<p>Regardless whether you are sending a sensitive information or a friendly message, using GPG keys is extremely helpful to verify that the author of the message is genuine. Thanks for reading, and in case of a query or suggestions to improve this post, please feel free to write in the comments section below.</p>[Ultimate Guide] How SSH works?2017-11-30T08:58:00+05:302017-11-30T08:58:00+05:30GeekyShacklebolttag:thegeekyway.com,2017-11-30:/ultimate-guide-how-ssh-works/<p>SSH is quite an interesting protocol in itself. A lot of people are using it for a secure communication between two machines. This blog post hits behind the scenes that go on, between machines connected via SSH.</p>
<p>You might have an experience of remote login on SSH. But have you …</p><p>SSH is quite an interesting protocol in itself. A lot of people are using it for a secure communication between two machines. This blog post hits behind the scenes that go on, between machines connected via SSH.</p>
<p>You might have an experience of remote login on SSH. But have you ever wondered about how internally these ssh-client and ssh-server respond? And If you want to explore the same? You are on the right page!<!--more--></p>
<h2>Brief about SSH</h2>
<ul>
<li>SSH or we can say Secure Shell is a cryptographic network protocol that’s used to provide security in communication between two machines over an unsecured network like our Internet.</li>
<li>SSH uses different authentication and encryption-decryption methods to make our connection secure between two remote machines.</li>
<li>It is better than other communication protocols like FTP, telnet, etc. The picture below describes how SSH encryption doesn't let someone sniff in its signals. If someone tries to intercept the signal, s/he would receive nothing but an encrypted data packet. To know more about how SSH better than others visit <a href="https://www.yireo.com/blog/1452-why-ssh-instead-of-ftp">here</a>.</li>
</ul>
<div style="text-align:center">
<div class="highlight"><pre><span></span><code><span class="o">!</span><span class="p">[</span><span class="n">An</span><span class="w"> </span><span class="n">un</span><span class="o">-</span><span class="n">encrypte</span><span class="w"> </span><span class="n">telnet</span><span class="w"> </span><span class="n">connection</span><span class="p">]({</span><span class="k">static</span><span class="p">}</span><span class="o">/</span><span class="n">uploads</span><span class="o">/</span><span class="n">images</span><span class="o">/</span><span class="mi">2017</span><span class="o">/</span><span class="mi">11</span><span class="o">/</span><span class="n">howsshworks1</span><span class="o">-</span><span class="mi">300</span><span class="n">x220</span><span class="o">.</span><span class="n">png</span><span class="w"> </span><span class="s2">"An un-encrypte telnet connection"</span><span class="p">)</span>
</code></pre></div>
</div>
<div style="text-align:center">
<div class="highlight"><pre><span></span><code><span class="o">!</span><span class="p">[</span><span class="n">An</span><span class="w"> </span><span class="n">encrypted</span><span class="w"> </span><span class="n">SSH</span><span class="w"> </span><span class="n">sesion</span><span class="p">]({</span><span class="k">static</span><span class="p">}</span><span class="o">/</span><span class="n">uploads</span><span class="o">/</span><span class="n">images</span><span class="o">/</span><span class="mi">2017</span><span class="o">/</span><span class="mi">11</span><span class="o">/</span><span class="n">howsshworks2</span><span class="o">-</span><span class="mi">300</span><span class="n">x219</span><span class="o">.</span><span class="n">png</span><span class="w"> </span><span class="s2">"An encrypted SSH sesion"</span><span class="p">)</span>
</code></pre></div>
</div>
<ul>
<li>For use cases of SSH, you may see <a href="http://matt.might.net/articles/ssh-hacks/">this</a>.</li>
</ul>
<h1>How SSH works?</h1>
<p>Before we actually get into the protocol, there is something that needs to be discussed.</p>
<h4>Symmetric and Asymmetric Encryption:</h4>
<p><strong>Symmetric Encryption</strong> is that in which only one key (let's say private key or secret key) is used both for encryption and decryption of the data transferred between client and server.</p>
<p>However, <strong>Asymmetric Encryption</strong> is that in which both keys (private as well as public key) is used for encryption and decryption.</p>
<p>The server uses client's public key to encrypt data for it. The client, on the other hand, uses its private key to decrypt the data on the other end that was encrypted by its public key. Similarly, server's public key is used by the client to encrypt the signal and server's private key is used by the server to decrypt the signal.</p>
<p>So, which one is used in SSH?</p>
<p>The answer is, SSH uses both symmetric and asymmetric encryption. Since asymmetric encryption is more time consuming, most of the SSH connections use symmetric encryption. The idea behind is that asymmetric encryption is used only to share a secret key (session key) using which, symmetric encryption can be done for further communication.</p>
<p>Now there are 2 versions of SSH that are commonly used. These are SSH version 1 and SSH version 2. The overall architecture in both versions differs a bit, so we'll discuss the protocol version 1 in detail and then see how does it differ from version 2 protocol.</p>
<h2>SSH Protocol Version 1</h2>
<p>The SSH connection is always invoked by a client to a server. Therefore, server authentication comes first than client authentication.</p>
<p><strong><em>STEP 1: Connect to simple FTP connection</em></strong></p>
<p>For a successful SSH establishment. A simple connection between a client and a server is a must. For the same reason, first of all, a simple (FTP/Telnet) connection is created between the client and the server. And with telnet, we get details like this:</p>
<div class="highlight"><pre><span></span><code><span class="n">coderunner</span><span class="nv">@geekyshacklebolt</span><span class="err">:</span><span class="o">~</span><span class="err">$</span><span class="w"> </span><span class="n">telnet</span><span class="w"> </span><span class="n">thegeekyway</span><span class="p">.</span><span class="n">com</span><span class="w"> </span><span class="mi">22</span>
<span class="n">Trying</span><span class="w"> </span><span class="mf">192.168.42.119</span><span class="p">...</span>
<span class="n">Connected</span><span class="w"> </span><span class="k">to</span><span class="w"> </span><span class="n">thegeekyway</span><span class="p">.</span><span class="n">com</span><span class="p">.</span>
<span class="k">Escape</span><span class="w"> </span><span class="k">character</span><span class="w"> </span><span class="k">is</span><span class="w"> </span><span class="s1">'^]'</span><span class="p">.</span>
<span class="n">SSH</span><span class="o">-</span><span class="mf">2.0</span><span class="o">-</span><span class="n">OpenSSH_7</span><span class="mf">.2</span><span class="n">p2</span><span class="w"> </span><span class="n">Ubuntu</span><span class="o">-</span><span class="mi">4</span><span class="n">ubuntu2</span><span class="mf">.2</span>
</code></pre></div>
<p>Here one can see that "<em><strong>SSH-2.0</strong>"</em> (in the last line). This is the version of SSH protocol that server is using. We also see the package version of OpenSSH is visible. This is how the client knows which version of SSH the server is using.</p>
<p>Now, it is the sole responsibility of the client to continue with the session if it supports the version shown by the server.</p>
<p><strong><em>STEP 2: Both server and client, now switch to a packet-based protocol</em></strong></p>
<p>In this, each packet consists of a 32-bit length field, 1-8 bytes of random padding to foil known-plaintext attacks (KPA), a one-byte packet type code, the packet payload data, and a four-byte integrity check field.</p>
<p>***STEP 3: Server provides session parameters to client </p>
<hr>
<p>As soon as the connection is established, server authentication starts. For this, the server will send some critical data to the client. This data includes:</p>
<ul>
<li>1) <strong>Server's host key</strong>: It is an RSA public key, which is stored in "known_hosts" file of the client (if you have already connected before with that server). You may see your known_hosts file here:</li>
</ul>
<div class="highlight"><pre><span></span><code><span class="n">coderunner</span><span class="nv">@geekyshacklebolt</span><span class="err">:</span><span class="o">~</span><span class="err">$</span><span class="w"> </span><span class="n">cd</span><span class="w"> </span><span class="p">.</span><span class="n">ssh</span><span class="o">/</span>
<span class="n">coderunner</span><span class="nv">@geekyshacklebolt</span><span class="err">:</span><span class="o">~/</span><span class="p">.</span><span class="n">ssh</span><span class="err">$</span><span class="w"> </span><span class="n">ls</span>
<span class="n">authorized_keys</span><span class="w"> </span><span class="n">id_rsa</span><span class="w"> </span><span class="n">id_rsa</span><span class="p">.</span><span class="n">pub</span><span class="w"> </span><span class="n">known_hosts</span>
</code></pre></div>
<p>At this point, the client will search for this "rsa_public" key in client's `known_hosts` file and if the key is not already present, then it may be the case of connecting with that server for the first time. So, in this case, what you would get is a "WARNING!" like: "<em>Are you sure you want to continue connecting?</em>"</p>
<div class="highlight"><pre><span></span><code><span class="n">coderunner</span><span class="nv">@geekyshacklebolt</span><span class="err">:</span><span class="o">~</span><span class="err">$</span><span class="w"> </span><span class="n">ssh</span><span class="w"> </span><span class="n">geekyshacklebolt</span>
<span class="n">The</span><span class="w"> </span><span class="n">authenticity</span><span class="w"> </span><span class="k">of</span><span class="w"> </span><span class="k">host</span><span class="w"> </span><span class="s1">'geekyshacklebolt (192.168.42.222)'</span><span class="w"> </span><span class="n">can</span><span class="err">'</span><span class="n">t</span><span class="w"> </span><span class="n">be</span><span class="w"> </span><span class="n">established</span><span class="p">.</span>
<span class="n">ECDSA</span><span class="w"> </span><span class="k">key</span><span class="w"> </span><span class="n">fingerprint</span><span class="w"> </span><span class="k">is</span><span class="w"> </span><span class="nl">SHA256</span><span class="p">:</span><span class="n">Ql</span><span class="o">/</span><span class="n">KnGlolY9eCGuYK3OX3opnSyJQzsbtM3DW</span><span class="o">/</span><span class="n">UZIxms</span><span class="p">.</span>
<span class="k">Are</span><span class="w"> </span><span class="n">you</span><span class="w"> </span><span class="n">sure</span><span class="w"> </span><span class="n">you</span><span class="w"> </span><span class="n">want</span><span class="w"> </span><span class="k">to</span><span class="w"> </span><span class="k">continue</span><span class="w"> </span><span class="n">connecting</span><span class="w"> </span><span class="p">(</span><span class="n">yes</span><span class="o">/</span><span class="k">no</span><span class="p">)</span><span class="vm">?</span>
</code></pre></div>
<p>If you're not connecting with the server for the first time but see this warning, then maybe the server's public key has been changed or you're trying to access a different machine altogether (may be going in hands of an attacker). Therefore this warning is quite useful.</p>
<ul>
<li>2) <strong>Server's server key</strong>: (There is no concept of server key in SSH-2) With host key, server also provide one server key.</li>
</ul>
<p>This server key goes on changing every hour or so. And this key may be of 768 bits or 1024 bits it depends on the configuration. You may find it at "/etc/ssh/" in "sshd_config" file. Let me see mine.</p>
<div class="highlight"><pre><span></span><code># Lifetime and size of ephemeral version 1 server key
KeyRegenerationInterval 3600
ServerKeyBits 1024
</code></pre></div>
<p>Yeah, mine is 1024 bits.</p>
<ul>
<li>3) <strong>8 Random Bytes</strong>: These random bytes are known as <em>check bytes</em>. It is necessary for the client to send these <em>check bytes</em> in its next reply.</li>
<li>4) <strong>Authentication methods and list of encryption algorithms</strong> <strong>supported by server:</strong> So, that client may decide which encryption algorithm it supports and which authentication methods the client has to follow. The symmetric encryption algorithm that is used to encrypt and decrypt large amounts of data is known as <strong>bulk cipher.</strong></li>
</ul>
<p>At this point, both sides also compute a common 128-bit <strong>session identifier</strong><em>,</em> which is used in some subsequent protocol operations to uniquely identify this SSH session. This is an MD5 hash of the <em>host key</em>, <em>server key</em>, and <em>check bytes</em> taken together.</p>
<p><strong><em>STEP 4: Session key generation and sending it to server</em></strong></p>
<p>Now the client has server's host key, server key, 8 random bytes, authentication methods and encryption algorithms list.</p>
<p>The client creates a symmetric session key for a bulk cipher that both client and server support. This key will be used for the entire session of SSH for both encryption and decryption. For a secure transmission, client double encrypts this key before sending it to server. First encryption is done by "server's host key" and second encryption is done by "server key". Encrypting the session key a second time with the server key provides a property called <strong><em>perfect forward secrecy</em></strong>. This double encryption enhances the security to great extent.</p>
<p>After double encrypting the session key, the client sends it to the server, along with the check bytes and a choice of algorithms.</p>
<p>Since it is difficult to have both server's private key and the server key (which keep changing in a fixed interval duration), it is very difficult to know the key. On the other hand, server has its private key and the "session key" that is shared by both client and server. With this data, the server can decrypt and get the session key for further communication.</p>
<p><strong><em>STEP 5: Confirmation from the server</em></strong></p>
<p>After sending the "session key" client just wait for the server to respond. Because only if the server is original and the one whose host key was provided to the client, then only it would be able to decrypt this session key using the server key, and the corresponding private key of server's host key.</p>
<p>The server receives this session key and decrypts it, to use it for further transmission of signals. This was the end of asymmetric cryptography. Now, when both server and client posses this symmetric key. The complete communication session would be dealing only with <em>this key</em>.</p>
<p><strong><em>STEP 6: Client Authentication begins</em></strong></p>
<p>To authenticates a client, the server may use the following methods:</p>
<ul>
<li>Password-based</li>
<li>Kerberos</li>
<li>Rhosts</li>
<li>Host keys based</li>
</ul>
<p>We'll explain each part in brief, and 'host keys based' in detail, as it is the most secured.</p>
<p>1. <strong>Password</strong>:</p>
<p>It is as simple as you log into any of your social websites. The server just asks you for your password to establish the SSH connection, and client takes the responsibility to transfer this password to the server. The session gets started as soon as you give your password. This method is not much recommended. Because if you are really security conscious that you are using SSH for remote login, then password-based authentication can be easily attacked. This type of authentication is convenient for the first time SSH users and those who travel a lot and don't carry their machines.</p>
<p>2. <strong>Kerberos</strong>:</p>
<p>It is a computer network authentication protocol that works on the basis of <em>tickets</em> to allow nodes communicating over a non-secure network to prove their identity to one another in a secure manner. It is not much used nowadays. OpenSSH provides Kerberos support only when using the SSH-1 protocol.</p>
<p>3. <strong>RHosts</strong>:</p>
<p>In this, the server has a list of host keys stored in /etc/ssh_known_host, and additionally, each user has host keys in \$HOME/.ssh/known_hosts. SSH uses the naming service to obtain the canonical name of the client host, looks for its public key in its known_host files, and requires the client to prove that it knows the private host key. This prevents IP and routing spoofing attacks (as long as the client machine private host key has not been leaked), but is still vulnerable to DNS (domain name server) attacks (to a limited extent), and relies on the integrity of the client machine as to who is requesting to log in. If maximal security is desired, only RSA authentication (host keys authentication) should be used.</p>
<p>4. <strong>Host keys based</strong>:</p>
<p>It is the most secure method of authentication for an SSH session. In this, client authentication is based on a pair of host keys i.e: the public key and the private key that can be seen in "\~/.ssh/" directory.</p>
<div class="highlight"><pre><span></span><code><span class="n">coderunner</span><span class="nv">@geekyshacklebolt</span><span class="err">:</span><span class="o">~</span><span class="err">$</span><span class="w"> </span><span class="n">cd</span><span class="w"> </span><span class="p">.</span><span class="n">ssh</span><span class="o">/</span>
<span class="n">coderunner</span><span class="nv">@geekyshacklebolt</span><span class="err">:</span><span class="o">~/</span><span class="p">.</span><span class="n">ssh</span><span class="err">$</span><span class="w"> </span><span class="n">ls</span>
<span class="n">authorized_keys</span><span class="w"> </span><span class="n">id_rsa</span><span class="w"> </span><span class="n">id_rsa</span><span class="p">.</span><span class="n">pub</span><span class="w"> </span><span class="n">known_hosts</span>
</code></pre></div>
<p>Here, <em>id_rsa</em> is your private (secret) key which should be kept a secret (not to be shared with anyone ever) and id_rsa.pub is your public key, which should be present to every server's (to whom you want to connect to) "authorized_keys" file.</p>
<p>If you don't have these key pair, you may generate it using the command:</p>
<div class="highlight"><pre><span></span><code>$<span class="w"> </span>ssh-keygen<span class="w"> </span>-t<span class="w"> </span>rsa<span class="w"> </span>-b<span class="w"> </span><span class="m">1024</span><span class="w"> </span>-C<span class="w"> </span><span class="s2">"your_email@example.com"</span>
</code></pre></div>
<p><em><strong>*note:</strong> these public and private keys are never used for either encryption or decryption of SSH session. These are only used to authenticate a client.</em></p>
<p>An RSA public key has 2 parts, the exponent, and the modulus.The modulus is the long number in the public key file.</p>
<ul>
<li>The client sends the modulus of its public key as an identifier, encrypted using the session key.</li>
<li>The server decrypts this identity and starts searching for its corresponding public key in "authorized_keys" file.</li>
<li>If the authorized public key is not found or is restricted to connect, then this authentication request fails. Otherwise, the process continues.</li>
</ul>
<p><strong><em>STEP 7: The Game of Challenge and Response</em></strong></p>
<ul>
<li>Now, server prepares a random 256 bit-string, and encrypt this string using the client's public key. Then this encrypted string is sent to the client as a <em>challenge. </em>The challenge for the client is to decrypt this random string and prove that it has the corresponding private key.</li>
<li>The client receives this encrypted string, and decrypts using its private key, and send it back to the server. But, this string should not be transmitted as it is. Therefore, client combines this challenge with session identifier to prepare an MD5 hash. And then sends its <em>response</em> to the server.</li>
<li>The server receives this <em>response</em> in the form of an MD5 hash. And, the server itself regenerate this, since it is already having the random string and the session identifier. The server compares the 2 hashes with each other, and if both come out to be same, then it means that client had successfully decrypted the string.</li>
</ul>
<p>The client is now authenticated, and SSH session starts with a terminal allotted to you to start writing commands.</p>
<p><strong>Integrity Checking:</strong></p>
<p>It is the process of comparing the state of currently stored data to the state of previously stored data. This protocol uses a weak integrity check e.i a 32-bit cyclic redundancy check or CRC-32. This sort of check is insufficient for detecting deliberate corruption but effective against accidental changes to data.</p>
<h2>SSH Protocol Version 2</h2>
<p>There are a lot of places where SSH-1 needed more improvements to make the protocol more secure. Therefore, this version 2 comes into play. It provides some necessary changes in protocol 1 to enhance its security. We will only discuss the changes and won't repeat the common steps.</p>
<h3>Protocol Differences</h3>
<p>SSH-1 consists of multiple functions in a single protocol. However, SSH-2 is build up in modules and consists of multiple protocols which work together like:</p>
<ul>
<li><strong>SSH transport layer protocol (SSH-TRANS)</strong></li>
<li><strong>SSH authentication protocol (SSH-AUTH)</strong></li>
<li><strong>SSH connection protocol (SSH-CONN)</strong></li>
</ul>
<p>Let's see their differences in brief.</p>
<p><u><strong>SSH-TRANS:</strong></u> This layer of protocol provides initial connection, packet-based protocol, server authentication, basic encryption and integrity check.</p>
<p><u><strong>SSH-AUTH:</strong></u> This layer of protocol is used by the client over SSH-TRANS to authenticate itself to server. And, it supports 3 authentication methods:</p>
<ul>
<li><strong>Public key:</strong> It is similar to "host based" of SSH-1. But, it is more general and can accommodate any public-key signature algorithm.</li>
<li><strong>Hostbased:</strong> It is similar to RhostsRSA of SSH-1 by providing cryptographic assurance of client's host identity.</li>
<li><strong>Password:</strong> It is similar to "Password Based" of SSH-1.</li>
</ul>
<h3>Key Differences</h3>
<p>The Key differences between SSH-1 and SSH-2 are as follows.</p>
<ul>
<li>Expanded algorithm negotiation</li>
<li>No server key</li>
<li>Certificates authorities for public keys</li>
<li>More flexible authentication</li>
<li>Stronger integrity checking</li>
<li>Periodic replacement of session key ("re-keying")</li>
</ul>
<p><strong>1. Expanded algorithm negotiation:</strong></p>
<p>In SSH-1, client used to select only one algorithm out of the list of algorithms supported by server, for all category works like, hash function, message authentication, session key exchange, etc. But, SSH-2 provides support for one algorithm per category.</p>
<p><strong>2. No server key:</strong></p>
<p>It was recommended that the session key shouldn't be developed alone by the client (as done in SSH 1). The idea was, neither the client nor the server should dictate the SSH session by giving a session key that is created only by one side. So, a new method was adopted in which both server and client equally contribute to the development of session key. This method was based on Diffie - Hellman algorithm.</p>
<p><em>The classic procedure of Diffie - Hellman algorithm to develop a session key is discussed below step-by-step:</em></p>
<ol>
<li>Firstly, both client and server agree on a large prime number, which will serve as a seed value.</li>
<li>Then, both parties agree on an encryption generator (typically AES), which will be used to manipulate the values in a predefined way. This encryption generator method is the one which will be supported by both server and client.</li>
<li>Independently, each party comes up with another prime number which is kept secret from the other party. This number is used as the private (secret) key for this interaction (this private key is different than the private SSH key used for authentication).</li>
<li>The generated private key (the secret to themselves), the encryption generator (common to both), and the shared prime number (common to both) are used to generate a public key, but which can be shared with the other party.</li>
<li>Both participants then exchange their generated public keys.</li>
<li>The receiving party uses their own private key, the other party's public key, and the original shared prime number to compute a shared secret key. Although this is independently computed by each party, using opposite private and public keys, will result in the <em>same</em> shared secret key.</li>
<li>The shared secret is then used to encrypt all communication that follows. This key is again known as a session key or symmetric key.</li>
</ol>
<p><strong>3. Certificate authorities for public keys:</strong></p>
<p>In SSH-1, there was no method to verify the ownership of the key. But, in SSH-2 we have a room for this as well. This is another layer of security in SSH-2. In which, the public keys of users are signed by some certificate authorities. The certificate attests and confirms the binding between a public key and a particular identity. The attestation is represented by a digital signature from a trusted third party.</p>
<p><strong>4. More flexible authentication:</strong></p>
<p>In SSH-1, client could authenticate itself to server using any one of the allowed authentication methods. And if it fails, then it means the connection is refused. But in SSH-2, if initial attempts of any authentication method (say public key) are failed, then the protocol may switch to other methods of authentication (say password). That's why SSH-2 gives more chances to establish a connection.</p>
<p><strong>5. Stronger Integrity checking:</strong></p>
<p>SSH-1 uses CRC-32 integrity check which is really weak and ineffective against deliberate corruption. On the other hand, SSH-2 uses cryptographically strong Message Authentication Code (MAC) algorithms to provide strong integrity and data origin assurance.</p>
<p><strong>6. Periodic replacement of session key ("re-keying")</strong></p>
<p>The concept was improved with an idea that the session key should not remain same for the complete session as we see in SSH-1. Therefore, in SSH 2, we may have a no. of session keys that keeps on changing with sessions, periodically.</p>
<p><strong>7. Implementation Differences</strong></p>
<p>There are mainly 4 Implementation differences in SSH-1 and SSH-2.</p>
<ul>
<li><strong>Host keys</strong>: SSH-1 and SSH-2 both manage host keys in different directory structures.</li>
<li><strong>No fallback to rsh:</strong> If a remote host has no SSH server running, then SSH can invoke <code>rsh</code> automatically, because SSH-1 supports <code>rsh</code>-style authentication as well. But SSH-2 don't have this feature, due to poor security of <code>rsh</code>.</li>
<li><strong>Setuid client:</strong> In SSH-1, the client needs to be <code>setuid</code> root, so that it has access to <em>read</em> for the <em>private host key</em> file, which is usually installed as <em>readable only</em> by the root user. But in SSH-2, the client doesn't need to be <code>setuid</code>root, due to its programs like <code>ssh-signer2</code>.</li>
<li><strong>SSH-1 backward compatibility:</strong> SSH-2 provide backward compatibility to SSH-1, if and only if <em>SSH-1 package</em> is installed on the same machine. The SSH-2 client and server simply run their SSH-1 counterparts, when they connect to a partner running the older protocol.</li>
</ul>
<p>We'll leave the rest for readers to explore on their own. If you've any questions, please feel free to ask in the comments section below.</p>