MAN.9FRONT.ORG RTFM


     RSA(8)                                                     RSA(8)

     NAME
          rsagen, rsafill, asn12rsa, rsa2asn1, rsa2pub, rsa2ssh,
          rsa2x509, rsa2csr, rsa2jwk, x5092pub - generate and format
          rsa keys

     SYNOPSIS
          rsagen [ -b nbits ] [ -t tag ]

          rsafill [ file ]

          asn12rsa [ -t tag ] [ file ]

          rsa2asn1 [ -a ] [ -f fmt ] [ file ]

          rsa2pub [ file ]

          ssh2rsa [ file ]

          rsa2ssh [ -c comment ] [ file ]

          rsa2jwk [ file ]

          rsa2x509 [ -e expiretime ] certinfo [ file ]

          rsa2csr subject [ file ]

          x5092pub [ -r ] [ file ]

     DESCRIPTION
          Plan 9 represents an RSA key as an attribute-value pair list
          prefixed with the string key; this is the generic key format
          used by factotum(4). A full RSA private key has the follow-
          ing attributes:

          proto  must be rsa

          size   the number of significant bits in n

          ek     the encryption exponent

          n      the product of !p and !q

          !dk    the decryption exponent

          !p     a large prime

          !q     another large prime

          !kp, !kq, !c2

     RSA(8)                                                     RSA(8)

                 parameters derived from the other attributes, cached
                 to speed decryption

          All the numbers are in hexadecimal except size, which is
          decimal.  An RSA public key omits the attributes beginning
          with `!'.  A key may have other attributes as well (for
          example, a service attribute identifying how this key is
          typically used), but to these utilities such attributes are
          merely comments.

          For example, a very small (and thus insecure) private key
          and corresponding public key might be:

               key proto=rsa size=8 ek=7 n=8F !dk=67 !p=B !q=D !kp=3 !kq=7 !c2=6
               key proto=rsa size=8 ek=7 n=8F

          Note that the order of the attributes does not matter.

          Rsagen prints a randomly generated RSA private key whose n
          has exactly nbits (default 2048) significant bits.  If tag
          is specified, it is printed between key and proto=rsa; typi-
          cally, tag is a sequence of attribute-value comments
          describing the key.

          Rsafill reads a private key, recomputes the !kp, !kq, and
          !c2 attributes if they are missing, and prints a full key.

          Asn12rsa reads an RSA private or public key stored as ASN.1
          encoded in the binary Distinguished Encoding Rules (DER) and
          prints a Plan 9 RSA key, inserting tag exactly as rsagen
          does.  ASN.1/DER is a popular key format on Unix and Win-
          dows; it is often encoded in text form using the Privacy
          Enhanced Mail (PEM) format in a section labeled as an ``RSA
          PRIVATE KEY.''  The command:

               auth/pemdecode 'RSA PRIVATE KEY' | auth/asn12rsa

          extracts the key section from a textual ASN.1/DER/PEM key
          into binary ASN.1/DER format and then converts it to a Plan
          9 RSA key.

          Ssh2rsa reads an RSA private key stored in the binary
          OpenSSH key format and prints a Plan 9 RSA key. The command:

               auth/pemdecode 'OPENSSH PRIVATE KEY' id_rsa | auth/ssh2rsa

          converts an id_rsa, as output by Unix ssh-keygen, to a Plan
          9 RSA key.

          Rsa2pub reads a Plan 9 RSA public or private key, removes
          the private attributes, and prints the resulting public key.
          Comment attributes are preserved.

     RSA(8)                                                     RSA(8)

          Rsa2asn1 is like rsa2pub but outputs the public key in
          ASN.1/DER format.  With the -a flag a private key is read
          and encoded in ANS.1/DER format.  With the -f flag, the for-
          mat of the ASN.1/DER encoded key is selected.  The supported
          formats are pkcs1 and spki, which refer to RFC3447 RSAPub-
          licKey and RFC5280 SubjectPublicKeyInfo formatted RSA keys
          respectively.  The default format is pkcs1.

          Rsa2ssh reads a Plan 9 RSA public or private key and prints
          the public portion in the format used by SSH2. The -c option
          will set the comment.

          Rsa2jwk reads a Plan 9 RSA public or private key and prints
          the public portion as a RFC7517 formated JSON Web Key.

          Rsa2x509 reads a Plan 9 RSA private key and writes a self-
          signed X.509 certificate encoded in ASN.1/DER format to
          standard output.  (Note that ASN.1/DER X.509 certificates
          are different from ASN.1/DER private keys).  The certificate
          uses the current time as its start time and expires
          expiretime seconds (default 3 years) later.  It contains the
          public half of the key and includes certinfo as the
          issuer/subject string (also known as a ``Distinguished
          Name'').  This info is typically in the form:

               C=US ST=NJ L=07974 O=Lucent OU='Bell Labs' CN=G.R.Emlin

          One can append further Distinguished Names, DNS Names and
          E-Mail addresses as a ``Subject Alternative Name'' separated
          with a comma after the main subject.

          The X.509 ASN.1/DER format is often encoded in text using a
          PEM section labeled as a ``CERTIFICATE.''  The command:

               auth/rsa2x509 'C=US OU=''Bell Labs''' file |
               auth/pemencode CERTIFICATE

          generates such a textual certificate.  Applications that
          serve TLS-encrypted sessions (for example, httpd(8),
          pop3(8), and tlssrv(8)) expect certificates in ASN.1/DER/PEM
          format.

          The Plan 9 RSA private key needs to be loaded into factotum
          for TLS server applications. It is recommended to put the
          key into secstore(1), avoiding it being stored unencrypted
          on the filesystem.

          Rsa2csr takes the subject and a RSA private key and outputs
          a signing request in ASN.1 format.

          The program x5092pub converts a binary certificate (or cer-
          tificate request when -r flag is given) read from file or

     RSA(8)                                                     RSA(8)

          stdin, and outputs the public key with a subject attribute
          on standard output.

     EXAMPLES
          Generate a fresh key and use it to start a TLS-enabled web
          server:

               auth/rsagen -t 'service=tls role=client owner=*' >key
               auth/rsa2x509 'C=US CN=*.cs.bell-labs.com' key |
                    auth/pemencode CERTIFICATE >cert
               cat key >/mnt/factotum/ctl
               ip/httpd/httpd -c cert

          Generate a fresh key and configure a remote Unix system to
          allow use of that key for logins:

               auth/rsagen -t 'service=ssh role=client' >key
               auth/rsa2ssh key | ssh unix 'cat >>.ssh/authorized_keys'
               cat key >/mnt/factotum/ctl
               ssh unix

          Convert a private key in PEM format (as generated by
          OpenSSL) and load it into factotum:

               auth/pemdecode 'PRIVATE KEY' key.pem |
                    auth/asn12rsa -t 'service=tls' >/mnt/factotum/ctl

          Generate a certificate signing request (CSR) in PEM format:

               auth/rsa2csr 'CN=example.com' key |
                    auth/pemencode 'CERTIFICATE REQUEST'

          Generate a tinc host key:

               auth/rsagen -t 'service=tinc role=client host=myhost' > myhost.key
               auth/rsa2pub < myhost.key |
                    auth/rsa2asn1 | auth/pemencode 'RSA PUBLIC KEY' > hosts/myhost

     SOURCE
          /sys/src/cmd/auth

     SEE ALSO
          factotum(4), pem(8),

     BUGS
          There are too many key formats.