rsa: print help if not args given

Signed-off-by: HeshamTB <hishaminv@gmail.com>

.gitignore

@@ -1,3 +1,13 @@
 __pycache__/
 keys/
 test-file
+
+#pyinstaller files
+dist/
+build/
+*.spec
+
+#venv dir
+venv/
+
+.idea/

LICENSE

@@ -0,0 +1,339 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Lesser General Public License instead.)  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
+source code.  And you must show them these terms so they know their
+rights.
+
+  We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+  Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                    GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License.  The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term "modification".)  Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+  1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+  2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) You must cause the modified files to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    b) You must cause any work that you distribute or publish, that in
+    whole or in part contains or is derived from the Program or any
+    part thereof, to be licensed as a whole at no charge to all third
+    parties under the terms of this License.
+
+    c) If the modified program normally reads commands interactively
+    when run, you must cause it, when started running for such
+    interactive use in the most ordinary way, to print or display an
+    announcement including an appropriate copyright notice and a
+    notice that there is no warranty (or else, saying that you provide
+    a warranty) and that users may redistribute the program under
+    these conditions, and telling the user how to view a copy of this
+    License.  (Exception: if the Program itself is interactive but
+    does not normally print such an announcement, your work based on
+    the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+    a) Accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of Sections
+    1 and 2 above on a medium customarily used for software interchange; or,
+
+    b) Accompany it with a written offer, valid for at least three
+    years, to give any third party, for a charge no more than your
+    cost of physically performing source distribution, a complete
+    machine-readable copy of the corresponding source code, to be
+    distributed under the terms of Sections 1 and 2 above on a medium
+    customarily used for software interchange; or,
+
+    c) Accompany it with the information you received as to the offer
+    to distribute corresponding source code.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form with such
+    an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable.  However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+  5. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+  6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+  9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+  10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+                            NO WARRANTY
+
+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License along
+    with this program; if not, write to the Free Software Foundation, Inc.,
+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+    Gnomovision version 69, Copyright (C) year name of author
+    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+  `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+  <signature of Ty Coon>, 1 April 1989
+  Ty Coon, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs.  If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.

MillerRabin.py

@@ -0,0 +1,33 @@
+
+# Copyright (C) 2019-2021 Hesham T. Banafa
+
+#From: https://stackoverflow.com/questions/17298130/working-with-large-primes-in-python
+from random import randrange
+def is_prime(n, k=10):
+    if n == 2:
+        return True
+    if not n & 1:
+        return False
+
+    def check(a, s, d, n):
+        x = pow(a, d, n)
+        if x == 1:
+            return True
+        for i in range(s - 1):
+            if x == n - 1:
+                return True
+            x = pow(x, 2, n)
+        return x == n - 1
+
+    s = 0
+    d = n - 1
+
+    while d % 2 == 0:
+        d >>= 1
+        s += 1
+
+    for i in range(k):
+        a = randrange(2, n - 1)
+        if not check(a, s, d, n):
+            return False
+    return True

OAEP.py

@@ -0,0 +1,24 @@
+# Copyright (C) 2019-2021 Hesham T. Banafa
+
+#From: https://stackoverflow.com/questions/39964383/implementation-of-i2osp-and-os2ip
+
+def i2osp(x, xLen):
+        if x >= 256**xLen:
+            raise ValueError("integer too large")
+        digits = []
+
+        while x:
+            digits.append(int(x % 256))
+            x //= 256
+        for i in range(xLen - len(digits)):
+            digits.append(0)
+        return digits[::-1]
+
+def os2ip(X):
+        xLen = len(X)
+        X = X[::-1]
+        x = 0
+        for i in range(xLen):
+            x += X[i] * 256**i
+        return x
+

README.md

@@ -0,0 +1,29 @@
+
+# hesham-rsa
+A simple program written in python to implement RSA public encryption. Used as Course EE-305 project KAU.
+# Installation 
+There is no packaging or installation. Works in current dir (portable) for now.
+
+    git clone https://apollo-server.ddns.net/gitea/Hesham/hesham-rsa.git
+    cd hesham-rsa
+
+# Usage
+
+    ./rsa.py [COMMAND] [ARGS]
+   or 
+   
+    python rsa.py [COMMAND] [ARGS]
+
+## generating keys
+to generate a key pair with and ID 
+
+    ./rsa.py gen [keysize] [keyID]
+All generated keys are saved in {$working_dir}/saves/
+## encrypting 
+
+    ./rsa.py encrypt "[message]" [RecieverKeyID] [SenderSignetureKeyID]
+## decrypting
+Assuming the encrypted message is encrypted to myPrivateKey
+    
+    ./rsa.py decrypt "[cipher]" [myPrivateKeyID]
+The signature is checked with all public keys stored in keys directory

TODO

@@ -1,11 +1,7 @@
-Add signing capability. (sign a word (last word?) using private key)
-	so reciever can decrypt using my public key to verify the sender.
 
 Add scrambling of padding to encrypted messages.
 https://www.inf.pucrs.br/~calazans/graduate/TPVLSI_I/RSA-oaep_spec.pdf
 
-Add cmd to list keys in keys dir and check if it has private key also.
-
 Add use SHA-1 to provide public key finger print (hashing function).
 
 Support reading file for encryption, decryption and maybe signing.
@@ -14,3 +10,5 @@ resources:
 	https://crypto.stackexchange.com/questions/1448/definition-of-textbook-rsa
 	https://crypto.stackexchange.com/questions/3608/why-is-padding-used-for-rsa-encryption-given-that-it-is-not-a-block-cipher
 	https://www.inf.pucrs.br/~calazans/graduate/TPVLSI_I/RSA-oaep_spec.pdf
+	https://stackoverflow.com/questions/17298130/working-with-large-primes-in-python
+	RSA Primitives documentation PKCS: https://tools.ietf.org/html/rfc8017#section-4

encodetest.py

@@ -1,4 +1,6 @@
+#!/usr/bin/python3
 
+# Copyright (C) 2019-2021 Hesham T. Banafa
 
 s = 'test message hello awdawd'
 print(s)
@@ -38,3 +40,14 @@ print(sig_enc)
 sig_un = en.decrypt(sig_enc,d,n)
 print(sig_un)
 print(key)
+
+import OAEP
+
+key = en.generateKeys("encode-test", 2048)
+x = int(en.encrypt("test message", (key[en.N], key[en.E])))
+print(x)
+encoded_msg = OAEP.i2osp(x, key[en.N].bit_length())
+print(encoded_msg)
+
+decoded = OAEP.os2ip(encoded_msg)
+print(decoded)

rsa.py

@@ -1,6 +1,8 @@
 #!/usr/bin/python3
 
-#program to generate rsa key pair using methods in EE-305
+# Copyright (C) 2019-2021 Hesham T. Banafa
+
+# program to generate rsa key pair using methods in EE-305
 # Hesham Banafa
 
 """
@@ -13,33 +15,56 @@ https://crypto.stackexchange.com/questions/13113/how-can-i-find-the-prime-number
 import math
 import os
 import sys
+import MillerRabin as mr
 
+VERSION = "1.2.2"
 keysFolder = "keys/"
 byteOrder = "little"
-N=0
-E=1
-D=2
-P=3
-Q=4
-PHI=5
-ID=6
+N = 0
+E = 1
+D = 2
+P = 3
+Q = 4
+PHI = 5
+ID = 6
+
 
 def main():
+    print("hesham-rsa version ", VERSION)
 
-    if sys.argv[1] == "gen": ##rsa gen <keysize> <keyname>
+    if len(sys.argv) == 1:
+        printHelp()
+        sys.exit(127)
+
+    if sys.argv[1] == "gen" and len(sys.argv) == 4:  ##rsa gen <keysize> <keyname>
         keyFileName = sys.argv[3]
+        if keyExist(keyFileName):
+            choice = input("overwrite key %s (y/n)" % keyFileName)
+            if choice == "y":
                 key = generateKeys(keyFileName, int(sys.argv[2]))
+            elif choice == "n":
+                sys.exit(0)
+            else:
+                print("unrecognized choice!")
+                sys.exit(1)
+        else:
+            key = generateKeys(keyFileName, int(sys.argv[2]))
+        print("e: ", key[E])
+        print("n: ", key[N])
+        print("d: ", key[D])
         printKey(key)
         try:
             saveKeyFile(key, keyFileName)
         except IOError:
             print("could not write file")
-            exit(1)
+            sys.exit(1)
         except Exception as ex:
             print(ex)
-            exit(1)
-    if len(sys.argv) == 5 or len(sys.argv) == 4:
-        if sys.argv[1] == "encrypt": ##rsa encrypt <message> <key> <signer>
+            sys.exit(1)
+        sys.exit(0)
+    if (
+        sys.argv[1] == "encrypt" and len(sys.argv) == 5
+    ):  ##rsa encrypt <message> <key> <signer>
         msg = sys.argv[2]
         msg_list = msg.split()
         keyName = sys.argv[3]
@@ -49,11 +74,18 @@ def main():
         key_public = (key[N], key[E])
         msg_encrypted = ""
         for word in msg_list:
-                msg_encrypted = msg_encrypted + " " + str(encrypt(word, key_public))
-            #msg_encrypted = encrypt(msg, key_public)
+            msg_encrypted = msg_encrypted + " " + hex(encrypt(word, key_public))
+        # msg_encrypted = encrypt(msg, key_public)
         print("Encrypted msg: \n", msg_encrypted)
-            print("Signed: \n", sign(msg_encrypted, signing_key))
-        if sys.argv[1] == "decrypt": ##rsa decrypt <cipher> <key>
+        print(
+            "Signed: \n", sign(msg_encrypted, signing_key)
+        )  ## Adds an encrypted sig at the end of message.
+        sys.exit(0)
+    elif sys.argv[1] == "encrypt":
+        print("Not enough arguments")
+        print("rsa encrypt <message> <key> <signer>")
+        sys.exit(1)
+    if sys.argv[1] == "decrypt" and len(sys.argv) == 4:  ##rsa decrypt "<cipher>" <key>
         cipher = sys.argv[2]
         cipher_list = cipher.split()
         sig = verify(cipher_list)
@@ -61,90 +93,152 @@ def main():
         msg_decrypted = ""
         key = readKeyFile(sys.argv[3])
         for cipher_word in cipher_list:
-                msg_decrypted = msg_decrypted + " " + str(decrypt(int(cipher_word),key[D],key[N]))
-            #with open(fileName, "r") as cipherFile:
-            #    cipher = int(cipherFile.readline()) ##one line may make problems later with padding
-            print("Signed by: ", sig)
+            msg_decrypted = (
+                msg_decrypted + " " + str(decrypt(int(cipher_word, 16), key[D], key[N]))
+            )
+        if sig == None:
+            print("\033[91mUnknown signature! \u2717" + "\033[0m")
+        else:
+            print("Signed by: \033[92m " + sig + " \u2713\033[0m")
         print("Decrypted message: \n", msg_decrypted)
+        sys.exit(0)
+    elif sys.argv[1] == "decrypt":
+        print("Not enough arguments")
+        print('rsa decrypt "<cipher>" <keyid>')
+        sys.exit(1)
     if sys.argv[1] == "list":
         listKeys()
+        sys.exit(0)
+    if sys.argv[1] == "export" and len(sys.argv) == 3:  # rsa export <key>
+        key_file_name = sys.argv[2]
+        exportKey(key_file_name)
+        sys.exit(0)
+    elif sys.argv[1] == "export":
+        printHelp()
+        sys.exit(1)
+    if sys.argv[1] == "crack" and len(sys.argv) == 3:  # rsa crack <key>
+        keyName = sys.argv[2]
+        cracked_key = crackKey2(keyName)
+        printKey(cracked_key)
+        sys.exit(0)
+    elif sys.argv[1] == "crack":
+        printHelp()
+        sys.exit(1)
+    if sys.argv[1] == "is_prime" and len(sys.argv) == 4:  # rsa is_prime <base> <N>
+        isPrime_cmd(0)
+        sys.exit(0)
+    if (
+        sys.argv[1] == "is_prime_mr" and len(sys.argv) == 4
+    ):  # rsa is_prime_mr <base> <N>
+        isPrime_cmd(1)
+        sys.exit(0)
+    if sys.argv[1] == "genrand" and len(sys.argv) == 3:  # rsa genrand <bits>
+        print(gen_random(int(sys.argv[2])))
+        sys.exit(0)
+    if sys.argv[1] == "genprime" and len(sys.argv) == 3:  # rsa genprime <bits>
+        print(getPrime(int(sys.argv[2])))
+        sys.exit(0)
+    if (
+        sys.argv[1] == "prime_factors" and len(sys.argv) == 4
+    ):  # rsa primefactors <base> <N>
+        prime_factors(sys.argv[3], sys.argv[2])
+        sys.exit(0)
+    if sys.argv[1] == "print" and len(sys.argv) == 3:  # rsa print <key>
+        printKey(readKeyFile(sys.argv[2]))
+        sys.exit(0)
+    elif sys.argv[1] == "print":
+        printHelp()
+        sys.exit(1)
+    if sys.argv[1] == "help":
+        printHelp()
+        sys.exit(0)
 
+    # No command exit code
+    printHelp()
+    sys.exit(127)
 
 
 def generateKeys(id, bits=64):
     from multiprocessing.pool import Pool
-    #Primes of size 32 bit random
-    #resulting in a 64-bit key mod
+
+    # Primes of size 32 bit random
+    # resulting in a 64-bit key mod
     pool = Pool()
-    result1 = pool.apply_async(getPrime, [int(bits/2)])
-    result2 = pool.apply_async(getPrime, [int(bits/2)])
+    result1 = pool.apply_async(getPrime, [int(bits / 2)])
+    result2 = pool.apply_async(getPrime, [int(bits / 2)])
     p = result1.get()
     q = result2.get()
-    n = p*q
-    #print("n: ", n)
+    n = p * q
+    # print("n: ", n)
 
-    #lamda(n) = LCM(p-1, q-1)
-    #Since LCM(a,b) = ab/GCD(a,b)
-    #gcd = math.gcd(p-1, q-1)
-    #print("GCD: ", gcd)
-    #lcm = abs((p-1) * (q-1)) / gcd
-    #print("LCM: ", lcm)
-    phi = (p-1)*(q-1)
-    #print("phi: ", phi)
-    #e exponant should be 1 < e < lamda(n) and GCD(e, lamda(n)) = 1 (coprime)
+    # lamda(n) = LCM(p-1, q-1)
+    # Since LCM(a,b) = ab/GCD(a,b)
+    # gcd = math.gcd(p-1, q-1)
+    # print("GCD: ", gcd)
+    # lcm = abs((p-1) * (q-1)) / gcd
+    # print("LCM: ", lcm)
+    phi = (p - 1) * (q - 1)
+    # print("phi: ", phi)
+    # e exponant should be 1 < e < lamda(n) and GCD(e, lamda(n)) = 1 (coprime)
     # recommended value is 65,537
     e = 65537
-    d = pow(e,-1,phi)
+    d = pow(e, -1, phi)  # d = e^-1 mod phi
     return (n, e, d, p, q, phi, id)
 
+
 def encrypt(message, publicKey):
     msg_text = message
     n = publicKey[N]
     e = publicKey[E]
-    print("using n: {0}, e: {1}".format(n, e))
+    # print("using n: {0}, e: {1}".format(n, e))
 
     msg_number_form = int.from_bytes(msg_text.encode(), byteOrder)
-    print("Word: %s or %d" % (msg_text, msg_number_form))
+    # print("Word: %s or %d" % (msg_text, msg_number_form))
 
     msg_encrypted_number_form = pow(msg_number_form, e, n)  # c = msg^e mod n
     return msg_encrypted_number_form
 
+
 def decrypt(cipher, privateKey, n):
     msg_encrypted_number_form = cipher
     d = privateKey
     msg_decrypted_number_form = pow(msg_encrypted_number_form, d, n)  # msg = c^d mod n
     msg_decrypted = int(msg_decrypted_number_form)
     try:
-        msg_decrypted = str(msg_decrypted.to_bytes(msg_decrypted.bit_length(), byteOrder).decode()).strip()
+        msg_decrypted = str(
+            msg_decrypted.to_bytes(msg_decrypted.bit_length(), byteOrder).decode()
+        ).strip()
     except UnicodeDecodeError:
-        print("Cant decrypt properly")
+        # print("decrypt: Cant decrypt properly")
+        return ""
     return msg_decrypted
 
+
 def getPrime(bits):
     while True:
-        #Byte order "little" or "big" does not matter here since we want a random number from os.urandom()
-        x = int.from_bytes(os.urandom(int(bits/8)), byteOrder)
-        print("trying: ", x, end="")
-        if isPrime(x):
-            print("\nprime: ", x)
+        # Byte order "little" or "big" does not matter here since we want a random number from os.urandom()
+        x = int.from_bytes(os.urandom(int(bits / 8)), byteOrder)
+        print("Trying: ", x, end="\n")
+        if mr.is_prime(x):
+            print("\nprime: ", x, "\n")
             return x
-        print("\r",end="")
+        # backTrack(x)
 
 
 def isPrime(number):
     if number == 2:
         return True
 
-    #if 2 devides number then num is not prime. pg.21
+    # if 2 devides number then num is not prime. pg.21
     if number % 2 == 0 or number == 1:
         return False
 
-    #largest integer less than or equal square root of number (K)
+    # largest integer less than or equal square root of number (K)
     rootOfNum = math.sqrt(number)
     K = math.floor(rootOfNum)
 
-    #Take odd D such that 1 < D <= K
-    #If D devides number then number is not prime. otherwise prime.
+    # Take odd D such that 1 < D <= K
+    # If D devides number then number is not prime. otherwise prime.
     for D in range(1, K, 2):
         if D % 2 == 0 or D == 1:
             pass
@@ -153,83 +247,253 @@ def isPrime(number):
                 return False
     return True
 
+
+def gen_random(bits: int):
+    x = int.from_bytes(os.urandom(int(bits / 8)), byteOrder)
+    return x
+
+
 def sign(encrypted_msg, key):
     enc_msg = str(encrypted_msg)
     encrypted_msg_list = enc_msg.split()
-    enc_sig = encrypt("sig:"+key[ID], (key[N], key[D]))
-    encrypted_msg_list.append(enc_sig)
+    enc_sig = encrypt("sig:" + key[ID], (key[N], key[D]))
+    encrypted_msg_list.append(hex(enc_sig))
     signed_msg = ""
     for word in encrypted_msg_list:
         signed_msg = str(signed_msg) + " " + str(word)
     return signed_msg.strip()
 
+
 def verify(cipher_list):
-    sig = "Unknown"
     local_keys = os.listdir(keysFolder)
-    cipher_list.reverse() #To get last word using index 0
+    cipher_list.reverse()  # To get last word using index 0
     encrypted_sig = cipher_list[0]
     cipher_list.reverse()
+    sig = None
     for key_name in local_keys:
         key = readKeyFile(key_name)
         print("Found key: ", key_name)
-        sig = str(decrypt(int(encrypted_sig), key[E], key[N]))
+        sig = str(decrypt(int(encrypted_sig, 16), key[E], key[N]))
         if "sig:" in sig:
-            return sig.replace("sig:","")
+            return sig.replace("sig:", "")
+        else:
+            continue
+    else:
+        return None
+
+
+def isPrime_cmd(func):
+    number = int_base_n_from_str(sys.argv[3], sys.argv[2])
+
+    if func == 0:
+        prime = isPrime(number)
+    elif func == 1:
+        prime = mr.is_prime(number)
+
+    if prime:
+        print("Prime")
+        # print(number)
+    else:
+        print("Not prime")
+
+
+def prime_factors(number, base):
+    num = int_base_n_from_str(number, base)
+    factors = {1: 1}
+    k = 0
+    while num % 2 == 0:
+        k += 1
+        num = num / 2
+    if k != 0:
+        factors.update({2: k})
+
+    for i in range(3, int(math.sqrt(num)) + 1, 2):
+        j = 0
+        while num % i == 0:
+            j += 1
+            num = num / i
+        if j != 0:
+            factors.update({i: j})
+    if num > 2:
+        factors.update({int(num): 1})
+
+    print(factors)
+
 
 def readKeyFile(keyName):
     key = tuple()
-    with open(keysFolder+keyName, "r") as keyFile:
+    with open(keysFolder + keyName, "r") as keyFile:
         tempkey = keyFile.readlines()
-        if len(tempkey) == 3: #means it only public part (n, e, id)
-            key = (int(tempkey[N].strip(), 16), int(tempkey[E].strip(), 16), 0, 0, 0, 0, tempkey[2])
-        else:                 #Make this a loop from 0 to 5
-            key = (int(tempkey[N].strip(), 16),
+        if len(tempkey) == 3:  # means it only public part (n, e, id)
+            key = (
+                int(tempkey[N].strip(), 16),
+                int(tempkey[E].strip(), 16),
+                0,
+                0,
+                0,
+                0,
+                tempkey[2],
+            )
+        else:  # Make this a loop from 0 to 5
+            key = (
+                int(tempkey[N].strip(), 16),
                 int(tempkey[E].strip(), 16),
                 int(tempkey[D].strip(), 16),
                 int(tempkey[P].strip(), 16),
                 int(tempkey[Q].strip(), 16),
                 int(tempkey[PHI].strip(), 16),
-            str(tempkey[ID].strip()))
+                str(tempkey[ID].strip()),
+            )
     return key
 
 
 def saveKeyFile(key, fileName):
     if not os.path.isdir(keysFolder):
         os.makedirs(keysFolder)
-    with open(keysFolder+fileName, "w") as keyFile:
+    with open(keysFolder + fileName, "w") as keyFile:
         for entry in range(0, 6):
-            keyFile.write(hex(key[entry])+"\n")
-        keyFile.write(key[ID]+"\n")
+            if key[entry] != 0:
+                keyFile.write(hex(key[entry]) + "\n")
+            else:
+                pass
+        keyFile.write(key[ID] + "\n")
+
 
 def printKey(key):
     n = key[N]
     e = key[E]
     d = key[D]
-    print("----------------------------------------------"+
-        "\nID: {}".format(key[ID]) +
-        "\n{}-BIT KEY".format(n.bit_length())+
-        "\nPUBLIC PART:"+
-        "\n{0}/{1}".format(hex(n), hex(e))+
-        "\nPTIVATE PART:"+
-        "\n{0}".format(hex(d))+
-        "\n----------------------------------------------",
+    id = key[ID]
+    print(
+        "----------------------------------------------"
+        + "\nID: {}".format(id)
+        + "\n{}-BIT KEY".format(n.bit_length())
+        + "\nPUBLIC PART:"
+        + "\n{0}/{1}".format(hex(n), hex(e))
+        + "\nPTIVATE PART:"
+        + "\n{0}".format(hex(d))
+        + "\n----------------------------------------------",
     )
 
+
 def listKeys():
     if not os.path.isdir(keysFolder):
         os.makedirs(keysFolder)
     local_keys = os.listdir(keysFolder)
-    print(local_keys)
     if len(local_keys) == 0:
+        print("Cant find local keys.")
         return
-    print("ID      PRIVATE")
-    print("________________")
+    print("ID      PRIVATE      SIZE")
+    print("-------------------------")
     for keyName in local_keys:
         key = readKeyFile(keyName)
         if key[D] == 0:
-            check = u''
-        else: check = u'\u2713'
-        print("{}   {}\n".format(key[ID], check))
+            check = "".strip()
+        else:
+            check = "\u2713"
+        print("%10s%7s%7s-bit" % (key[ID].strip(), check, key[N].bit_length()))
+
+
+def exportKey(keyFileName):
+    key = readKeyFile(keyFileName)
+    public_key = (key[N], key[E], 0, 0, 0, 0, key[ID])
+    saveKeyFile(public_key, key[ID] + "-public")
+    print("Saved public form of key {} in keys folder".format(key[ID]))
+
+
+def crackKey(keyName):
+    print("in crack")
+    key = readKeyFile(keyName)
+    n = key[N]
+    for number in range(7, n - 1):
+        if mr.is_prime(number):
+            print("Trying prime: ", number, end="\r")
+            # if number devides n then it p or q
+            if n % number == 0:
+                p = number
+                q = int(n / p)
+                phi = (p - 1) * (q - 1)
+                e = 65537
+                d = pow(e, -1, phi)
+                key_cracked = (n, e, d, p, q, phi, str(keyName + "-cracked"))
+                return key_cracked
+            else:
+                pass
+        else:
+            pass
+
+
+def crackKey2(keyName):
+    print("in crack")
+    key = readKeyFile(keyName)
+    n = key[N]
+    print("n: ", n)
+    bits = int(n.bit_length() / 2)
+    print("bits: ", bits)
+    while True:
+        number = int.from_bytes(os.urandom(int(bits / 8)), byteOrder)
+        if number == 0 or number == 1:
+            continue
+        print("Trying prime: ", number, end="\r")
+        # if number devides n then it p or q
+        if n % number == 0:
+            print("\nFound a factor")
+            p = number
+            print("p: ", p)
+            q = int(n / p)
+            phi = (p - 1) * (q - 1)
+            if phi == 0:
+                continue
+            e = 65537
+            d = pow(e, -1, phi)
+            key_cracked = (n, e, d, p, q, phi, str(keyName + "-cracked"))
+            print(key_cracked)
+            return key_cracked
+        else:
+            continue
+
+
+def printHelp():
+    print("commands:")
+    print("rsa gen <keysize> <keyname>")
+    print("rsa encrypt <message> <key> <signer>")
+    print('rsa decrypt "<cipher>" <key>')
+    print("rsa export <key>")
+    print("rsa crack <key>")
+    print("rsa print <key>")
+    print("rsa list")
+
+
+def backTrack(x):
+    # Back track and clear terminal with length of x
+    length = len(str(x))
+    while length > 0:
+        print("\b", end="")
+        length -= 1
+
+
+def keyExist(keyName):
+    exist = os.path.exists(keysFolder + keyName)
+    return exist
+
+
+def int_base_n_from_str(st: str, base):
+    try:
+        base = int(base)
+    except ValueError as e:
+        print(
+            f"Value {sys.argv[2]} is not a valid base (2, 8, 10, 16)", file=sys.stderr
+        )
+        exit(-1)
+    try:
+        number = int(st, base)
+    except ValueError as e:
+        print(
+            f"Value {sys.argv[3]} is not valid for as a base {base} number",
+            file=sys.stderr,
+        )
+        exit(-1)
+    return number
 
 
 if __name__ == "__main__":