⑴ 電腦RSA是加密的那裡怎麼找到
1，電腦上的RSA加密是一種公開密鑰密碼體制。所謂的公開密鑰密碼體制就是使用不同的加密密鑰與解密密鑰，是一種「由已知加密密鑰推導出解密密鑰在計算上是不可行的」密碼體制。
2，在公開密鑰密碼體制中，加密密鑰（即公開密鑰）PK是公開信息，而解密密鑰（即秘密密鑰）SK是需要保密的。加密演算法E和解密演算法D也都是公開的。雖然解密密鑰SK是由公開密鑰PK決定的，但卻不能根據PK計算出SK。
3，正是基於這種理論，1978年出現了著名的RSA演算法，它通常是先生成一對RSA 密鑰，其中之一是保密密鑰，由用戶保存；另一個為公開密鑰，可對外公開，甚至可在網路伺服器中注冊。為提高保密強度，RSA密鑰至少為500位長，一般推薦使用1024位。這就使加密的計算量很大。
4，RSA演算法是第一個能同時用於加密和數字簽名的演算法，也易於理解和操作。RSA是被研究得最廣泛的公鑰演算法，從提出到現今的三十多年裡，經歷了各種攻擊的考驗，逐漸為人們接受，普遍認為是目前最優秀的公鑰方案之一。
5，平時使用的https中的ssl3.0和TSL1.0使用了RSA來加密密鑰，還有就是數字證書、數字簽名、數字簽章、數字水印、數字信封等。如：銀行的u盾、銀行卡的刷卡機、淘寶的數字證書都使用了RSA進行加密。
⑵ 非對稱加密之-RSA加密
對一個大整數進行因數分解，在高等數學中叫做費馬大定理，至今沒有被破解
RSA演算法是最流行的公鑰密碼演算法，使用長度可以變化的密鑰。RSA是第一個既能用於數據加密也能用於數字簽名的演算法。
這是目前地球上最重要的加密演算法
至此，所有計算完成。
將 n和e封裝成公鑰 ， n和d封裝成私鑰 。
回顧上面的密鑰生成步驟，一共出現六個數字：
這六個數字之中，公鑰用到了兩個（n和e），其餘四個數字都是不公開的。其中最關鍵的是d，因為n和d組成了私鑰，一旦d泄漏，就等於私鑰泄漏。
那麼， 有無可能在已知n和e的情況下，推導出d？
最終轉換成->結論： 如果n可以被因數分解，d就可以算出，也就意味著私鑰被破解。
第一步 ：首先生成秘鑰對
第二步 ：公鑰加密
第三步 ：私鑰解密
幾個全局變數解說：
關於加密填充方式：之前以為上面這些操作就能實現rsa加解密，以為萬事大吉了，呵呵，這事還沒完，悲劇還是發生了， android這邊加密過的數據，伺服器端死活解密不了， ，這造成了在android機上加密後無法在伺服器上解密的原因，所以在實現的時候這個一定要注意
實現分段加密：搞定了填充方式之後又自信的認為萬事大吉了，可是意外還是發生了，RSA非對稱加密內容長度有限制，1024位key的最多隻能加密127位數據，否則就會報錯(javax.crypto.IllegalBlockSizeException: Data must not be longer than 117 bytes) ，RSA 是常用的非對稱加密演算法。最近使用時卻出現了「不正確的長度」的異常，研究發現是由於待加密的數據超長所致。RSA 演算法規定：待加密的位元組數不能超過密鑰的長度值除以 8 再減去 11（即：KeySize / 8 - 11），而加密後得到密文的位元組數，正好是密鑰的長度值除以 8（即：KeySize / 8）。
愛麗絲選擇了61和53。（實際應用中，這兩個質數越大，就越難破解。）
愛麗絲就把61和53相乘
n的長度就是密鑰長度。3233寫成二進制是110010100001，一共有12位，所以這個密鑰就是12位。實際應用中，RSA密鑰一般是1024位，重要場合則為2048位
愛麗絲算出φ(3233)等於60×52，即3120。
愛麗絲就在1到3120之間，隨機選擇了17。（實際應用中，常常選擇65537。）
所謂 "模反元素" 就是指有一個整數d，可以使得ed被φ(n)除的余數為1。
這個式子等價於
於是，找到模反元素d，實質上就是對下面這個二元一次方程求解。
已知 e=17, φ(n)=3120，
至此所有計算完成
在愛麗絲的例子中，n=3233，e=17，d=2753，所以公鑰就是 (3233,17)，私鑰就是（3233, 2753）。
實際應用中，公鑰和私鑰的數據都採用 ASN.1 格式表達
回顧上面的密鑰生成步驟，一共出現六個數字：
這六個數字之中，公鑰用到了兩個（n和e），其餘四個數字都是不公開的。其中最關鍵的是d，因為n和d組成了私鑰，一旦d泄漏，就等於私鑰泄漏。
那麼，有無可能在已知n和e的情況下，推導出d？
結論：如果n可以被因數分解，d就可以算出，也就意味著私鑰被破解。
可是，大整數的因數分解，是一件非常困難的事情。目前，除了暴力破解，還沒有發現別的有效方法。維基網路這樣寫道
舉例來說，你可以對3233進行因數分解（61×53），但是你沒法對下面這個整數進行因數分解。
它等於這樣兩個質數的乘積
事實上，RSA加密的方式原理是一個高等數學中沒有被解決的難題，所有沒有可靠的RSA的破解方式
⑶ 請較為詳細地描述rsa加密演算法的全過程
RSA演算法非常簡單，概述如下：
找兩素數p和q
取n=p*q
取t=(p-1)*(q-1)
取任何一個數e,要求滿足e<t並且e與t互素（就是最大公因數為1）
取d*e%t==1
這樣最終得到三個數： n d e
設消息為數M (M <n)
設c=(M**d)%n就得到了加密後的消息c
設m=(c**e)%n則 m == M，從而完成對c的解密。
註：**表示次方,上面兩式中的d和e可以互換。
在對稱加密中：
n d兩個數構成公鑰，可以告訴別人；
n e兩個數構成私鑰，e自己保留，不讓任何人知道。
給別人發送的信息使用e加密，只要別人能用d解開就證明信息是由你發送的，構成了簽名機制。
別人給你發送信息時使用d加密，這樣只有擁有e的你能夠對其解密。
rsa的安全性在於對於一個大數n，沒有有效的方法能夠將其分解
從而在已知n d的情況下無法獲得e；同樣在已知n e的情況下無法
求得d。
rsa簡潔幽雅，但計算速度比較慢，通常加密中並不是直接使用rsa 來對所有的信息進行加密，
最常見的情況是隨機產生一個對稱加密的密鑰，然後使用對稱加密演算法對信息加密，之後用
RSA對剛才的加密密鑰進行加密。
最後需要說明的是，當前小於1024位的N已經被證明是不安全的
自己使用中不要使用小於1024位的RSA，最好使用2048位的。
⑷ java rsa私鑰加密
java rsa私鑰加密是什麼？讓我們一起來了解一下吧！
java rsa私鑰加密是一種加密演算法。私鑰加密演算法是用私鑰來進行加密與解密信息。私鑰加密也被稱作對稱加密，原因是加密與解密使用的秘鑰是同一個。
RSA加密需要注意的事項如下：
1. 首先產生公鑰與私鑰
2. 設計加密與解密的演算法
3. 私鑰加密的數據信息只能由公鑰可以解密
4. 公鑰加密的數據信息只能由私鑰可以解密
實戰演練，具體步驟如下： public class RsaCryptTools { private static final String CHARSET = "utf-8"; private static final Base64.Decoder decoder64 = Base64.getDecoder(); private static final Base64.Encoder encoder64 = Base64.getEncoder(); /** * 生成公私鑰 * @param keySize * @return * @throws NoSuchAlgorithmException */ public static SecretKey generateSecretKey(int keySize) throws NoSuchAlgorithmException { //生成密鑰對 KeyPairGenerator keyGen = KeyPairGenerator.getInstance("RSA"); keyGen.initialize(keySize, new SecureRandom()); KeyPair pair = keyGen.generateKeyPair(); PrivateKey privateKey = pair.getPrivate(); PublicKey publicKey = pair.getPublic(); //這里可以將密鑰對保存到本地 return new SecretKey(encoder64.encodeToString(publicKey.getEncoded()), encoder64.encodeToString(privateKey.getEncoded())); } /** * 私鑰加密 * @param data * @param privateInfoStr * @return * @throws IOException * @throws InvalidCipherTextException */ public static String encryptData(String data, String privateInfoStr) throws IOException, InvalidKeySpecException, NoSuchAlgorithmException, InvalidKeyException, NoSuchPaddingException, BadPaddingException, IllegalBlockSizeException { Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding"); cipher.init(Cipher.ENCRYPT_MODE, getPrivateKey(privateInfoStr)); return encoder64.encodeToString(cipher.doFinal(data.getBytes(CHARSET))); } /** * 公鑰解密 * @param data * @param publicInfoStr * @return */ public static String decryptData(String data, String publicInfoStr) throws NoSuchPaddingException, NoSuchAlgorithmException, InvalidKeySpecException, InvalidKeyException, BadPaddingException, IllegalBlockSizeException, UnsupportedEncodingException { byte[] encryptDataBytes=decoder64.decode(data.getBytes(CHARSET)); //解密 Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding"); cipher.init(Cipher.DECRYPT_MODE, getPublicKey(publicInfoStr)); return new String(cipher.doFinal(encryptDataBytes), CHARSET); } private static PublicKey getPublicKey(String base64PublicKey) throws NoSuchAlgorithmException, InvalidKeySpecException { X509EncodedKeySpec keySpec = new X509EncodedKeySpec(Base64.getDecoder().decode(base64PublicKey.getBytes())); KeyFactory keyFactory = KeyFactory.getInstance("RSA"); return keyFactory.generatePublic(keySpec); } private static PrivateKey getPrivateKey(String base64PrivateKey) throws NoSuchAlgorithmException, InvalidKeySpecException { PrivateKey privateKey = null; PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(Base64.getDecoder().decode(base64PrivateKey.getBytes())); KeyFactory keyFactory = null; keyFactory = KeyFactory.getInstance("RSA"); privateKey = keyFactory.generatePrivate(keySpec); return privateKey; } /** * 密鑰實體 * @author hank * @since 2020/2/28 0028 下午 16:27 */ public static class SecretKey { /** * 公鑰 */ private String publicKey; /** * 私鑰 */ private String privateKey; public SecretKey(String publicKey, String privateKey) { this.publicKey = publicKey; this.privateKey = privateKey; } public String getPublicKey() { return publicKey; } public void setPublicKey(String publicKey) { this.publicKey = publicKey; } public String getPrivateKey() { return privateKey; } public void setPrivateKey(String privateKey) { this.privateKey = privateKey; } @Override public String toString() { return "SecretKey{" + "publicKey='" + publicKey + '\'' + ", privateKey='" + privateKey + '\'' + '}'; } } private static void writeToFile(String path, byte[] key) throws IOException { File f = new File(path); f.getParentFile().mkdirs(); try(FileOutputStream fos = new FileOutputStream(f)) { fos.write(key); fos.flush(); } } public static void main(String[] args) throws NoSuchAlgorithmException, NoSuchPaddingException, IOException, BadPaddingException, IllegalBlockSizeException, InvalidKeyException, InvalidKeySpecException { SecretKey secretKey = generateSecretKey(2048); System.out.println(secretKey); String enStr = encryptData("你好測試測試", secretKey.getPrivateKey()); System.out.println(enStr); String deStr = decryptData(enStr, secretKey.getPublicKey()); System.out.println(deStr); enStr = encryptData("你好測試測試hello", secretKey.getPrivateKey()); System.out.println(enStr); deStr = decryptData(enStr, secretKey.getPublicKey()); System.out.println(deStr); } }
⑸ 如何使用16進制編碼的RSA公鑰進行RSA加密
我們來回顧一下RSA的加密演算法。我們從公鑰加密演算法和簽名演算法的定義出發，用比較規范的語言來描述這一演算法。RSA公鑰加密體制包含如下3個演算法：KeyGen（密鑰生成演算法），Encrypt（加密演算法）以及Decrypt（解密演算法）。(PK,SK)\leftarrowKeyGen(\lambda)。密鑰生成演算法以安全常數\lambda作為輸入，輸出一個公鑰PK，和一個私鑰SK。安全常數用於確定這個加密演算法的安全性有多高，一般以加密演算法使用的質數p的大小有關。\lambda越大，質數p一般越大，保證體制有更高的安全性。在RSA中，密鑰生成演算法如下：演算法首先隨機產生兩個不同大質數p和q，計算N=pq。隨後，演算法計算歐拉函數\varphi(N)=(p-1)(q-1)。接下來，演算法隨機選擇一個小於\varphi(N)的整數e，並計算e關於\varphi(N)的模反元素d。最後，公鑰為PK=(N,e)，私鑰為SK=（N,d）。CT\leftarrowEncrypt(PK,M)。加密演算法以公鑰PK和待加密的消息M作為輸入，輸出密文CT。在RSA中，加密演算法如下：演算法直接輸出密文為CT=M^e\mod\varphi(N)M\leftarrowDecrypt(SK,CT)。解密演算法以私鑰SK和密文CT作為輸入，輸出消息M。在RSA中，解密演算法如下：演算法直接輸出明文為M=CT^d\mod\varphi(N)。由於e和d在\varphi(N)下互逆，因此我們有：CT^d=M^{ed}=M\mod\varphi(N)所以，從演算法描述中我們也可以看出：公鑰用於對數據進行加密，私鑰用於對數據進行解密。當然了，這個也可以很直觀的理解：公鑰就是公開的密鑰，其公開了大家才能用它來加密數據。私鑰是私有的密鑰，誰有這個密鑰才能夠解密密文。否則大家都能看到私鑰，就都能解密，那不就亂套了。=================分割線=================我們再來回顧一下RSA簽名體制。簽名體制同樣包含3個演算法：KeyGen（密鑰生成演算法），Sign（簽名演算法），Verify（驗證演算法）。(PK,SK)\leftarrowKeyGen(\lambda)。密鑰生成演算法同樣以安全常數\lambda作為輸入，輸出一個公鑰PK和一個私鑰SK。在RSA簽名中，密鑰生成演算法與加密演算法完全相同。\sigma\leftarrowSign(SK,M)。簽名演算法以私鑰SK和待簽名的消息M作為輸入，輸出簽名\sigma。在RSA簽名中，簽名演算法直接輸出簽名為\sigma=M^d\mod\varphi(N)。注意，簽名演算法和RSA加密體制中的解密演算法非常像。b\leftarrowVerify(PK,\sigma,M)。驗證演算法以公鑰PK，簽名\sigma以及消息M作為輸入，輸出一個比特值b。b=1意味著驗證通過。b=0意味著驗證不通過。在RSA簽名中，驗證演算法首先計算M'=\sigma^e\mod\varphi(N)，隨後對比M'與M，如果相等，則輸出b=1，否則輸出b=0。注意：驗證演算法和RSA加密體制中的加密演算法非常像。所以，在簽名演算法中，私鑰用於對數據進行簽名，公鑰用於對簽名進行驗證。這也可以直觀地進行理解：對一個文件簽名，當然要用私鑰，因為我們希望只有自己才能完成簽字。驗證過程當然希望所有人都能夠執行，大家看到簽名都能通過驗證證明確實是我自己簽的。=================分割線=================那麼，為什麼題主問這么一個問題呢？我們可以看到，RSA的加密/驗證，解密/簽字過程太像了。同時，RSA體制本身就是對稱的：如果我們反過來把e看成私鑰，d看成公鑰，這個體制也能很好的執行。我想正是由於這個原因，題主在學習RSA體制的時候才會出現這種混亂。那麼解決方法是什麼呢？建議題主可以學習一下其他的公鑰加密體制以及簽名體制。其他的體制是沒有這種對稱性質的。舉例來說，公鑰加密體制的話可以看一看ElGamal加密，以及更安全的Cramer-Shoup加密。簽名體制的話可以進一步看看ElGamal簽名，甚至是BLS簽名，這些體制可能能夠幫助題主更好的弄清加密和簽名之間的區別和潛在的聯系。至於題主問的加密和簽名是怎麼結合的。這種體制叫做簽密方案（SignCrypt），RSA中，這種簽密方案看起來特別特別像，很容易引起混亂。在此我不太想詳細介紹RSA中的加密與簽字結合的方案。我想提醒題主的是，加密與簽字結合時，兩套公私鑰是不同的。
⑹ RSA加解密原理
RSA是目前使用最為廣泛的公鑰密碼演算法，公鑰加密也稱為非對稱加密，與對稱加密的最大區別在於加密與解密使用不同的密鑰。
在RSA中，明文、密文和密鑰都是數字，假設公鑰用二元組(E,N)來表示，私鑰用(D,N)來表示，其中E、D、N都是數字，那麼加解密過程可表示如下：
可見，在RSA中，不論加密還是解密，都可歸結為求x的y次冪對m取余問題。
生成RSA密鑰可分成以下4步：
首先准備兩個很大的質數p和q，那麼N = p * q。
L = lcm(p-1, q-1)
由於存在恆等式gcd(a,b) * lcm(a,b) = a * b，求lcm可轉換為求gcd，而求gcd可通過歐幾里德演算法在對數時間內算出。
E是一個比1大、比L小的數，且滿足E與L互質，即有：gcd(E,L)=1, 1 < E < L。gcd(E,L)=1是為了保證後面要求的數字D一定存在。
可不斷地生成[2,L-1]之間的隨機數作為E的候選數，檢查是否滿足條件，直到找出符合要求的E為止。
至此，E和N都已求出，那麼公鑰(E,N)也就得到了。
數D是由數E計算得到的，D、E和L之間滿足關系：E * D mod L = 1, 1 < D < L。
只要D滿足上述條件，那麼通過E與N加密的內容，就可通過D和N進行解密。
求D也可採用類似求E的方法，不斷產生隨機數去試，直到找出滿足條件的D為止，這樣私鑰(D,N)也准備好了。
為方面說明，這里用較小的數計算。先准備兩個質數，例如，p=17, q=19，那麼N=17*19=323，L=lcd(16,18)=144。
滿足gcd(E,L)=1的數很多，例如5,7,11,13,25等，這里取E=5。
滿足E*D mod L = 1的數也很多，這里取D=29。
到這里，公私鑰都有了，公鑰為(5,323)，私鑰為(29,323)，公鑰可任意公開，私鑰則保密。
明文必須是小於N的數，因為加密運算中要求mod N。假設明文是123，用公鑰(5,323)對其加密：
再用私鑰(29,323)對密文225進行解密：
解出的明文與原始明文一致。
⑺ RSA加密、解密、簽名、驗簽的原理及方法
RSA加密是一種非對稱加密。可以在不直接傳遞密鑰的情況下，完成解密。這能夠確保信息的安全性，避免了直接傳遞密鑰所造成的被破解的風險。是由一對密鑰來進行加解密的過程，分別稱為公鑰和私鑰。兩者之間有數學相關，該加密演算法的原理就是對一極大整數做因數分解的困難性來保證安全性。通常個人保存私鑰，公鑰是公開的（可能同時多人持有）。
加密和簽名都是為了安全性考慮，但略有不同。常有人問加密和簽名是用私鑰還是公鑰？其實都是對加密和簽名的作用有所混淆。簡單的說，加密是為了防止信息被泄露，而簽名是為了防止信息被篡改。這里舉2個例子說明。
RSA的加密過程如下：
RSA簽名的過程如下：
總結：公鑰加密、私鑰解密、私鑰簽名、公鑰驗簽。
RSA加密對明文的長度有所限制，規定需加密的明文最大長度=密鑰長度-11（單位是位元組，即byte），所以在加密和解密的過程中需要分塊進行。而密鑰默認是1024位，即1024位/8位-11=128-11=117位元組。所以默認加密前的明文最大長度117位元組，解密密文最大長度為128字。那麼為啥兩者相差11位元組呢？是因為RSA加密使用到了填充模式（padding），即內容不足117位元組時會自動填滿，用到填充模式自然會佔用一定的位元組，而且這部分位元組也是參與加密的。
⑻ linux生成的rsa秘鑰在哪
方法一， 有的時候經常需要登錄ssh，每次都需要輸入密碼，會比較繁瑣。所以設置了一下使用RSA公鑰認證的方式登錄Linux。 首先需要在伺服器端設置/etc/ssh/sshd_config # vim /etc/ssh/sshd_config 修改如下兩行為yes。其實大多數情況下不用修改，默認就是yes。 RSAAuthentication yes PubkeyAuthentication yes (1) 如果客戶機和伺服器都是Linux機器，那麼我們使用下面的方法：(後面第2節會提到怎麼在Windows下使用Putty生成密鑰對) 我們需要在客戶端生成RSA密鑰對。使用ssh-keygen命令： # ssh-keygen -t rsa 參數t的意思是type，後面跟著加密類型，這里我們是rsa。 然後會提示你輸入密鑰保存完成文件名，這里我們需要使用默認的id_rsa，之後才能正常才能登錄。如果你生成的密鑰作為其他用處，那麼可以命名為其他名稱： Generating public/private rsa key pair. Enter file in which to save the key (/home/cake/.ssh/id_rsa): 之後會提示你輸入一個passphrase，我們這里可以留空，這樣我們登錄的時候就不許輸入密碼。 Enter passphrase (empty for no passphrase): Enter same passphrase again: 然後會提示你密鑰生成成功。這是你的私鑰保存為~/.ssh/id_rsa，你的公鑰是~/.ssh/id_rsa.pub 我們現在需要做的是，把id_rsa.pub的內容，添加的伺服器端的~/.ssh/autherized_keys文件最後。 你可以把這個文件上傳到伺服器端，然後使用命令： # cat id_rsa.pub >> ~/.ssh/autherized_keys 到這里就完成了。 (2) 在Windows下使用Putty生成密鑰對： Putty的安裝目錄下有個puttygen.exe程序，我們運行這個程序。 之後點擊Generate，開始生成密鑰對。我們需要根據提示，在指定方框內隨機滑動滑鼠。這是為了根據滑鼠軌跡，產生一些隨機數據。 之後生成結束，我們點擊Save Private Key將私鑰存放在某個目錄中。然後賦值最上面文本框中的全部內容，粘貼到Linux伺服器端的autherized_key的最後。 我們現在可以關閉這個小程序。 現在打開Putty，在左邊的選項中，選擇Conneciton–SSH–Auth，在Private key file for authentication中，選擇剛才保存的私鑰路徑就可以了。 到此位置，Putty也可以不用密碼登錄了。 方法二 使用Linux主機生成的密匙 1、生成密匙 [root@ .ssh]#ssh-keygen -t rsa Generating public/private rsa key pair. Enter file in which to save the key (/root/.ssh/id_rsa): Enter passphrase (empty for no passphrase): Enter same passphrase again: Your identification has been saved in /root/.ssh/id_rsa. Your public key has been saved in /root/.ssh/id_rsa.pub. The key fingerprint is: e4:9a:47:a7:b4:8a:0b:98:07:b8:70:de:6b:16:2c:0croot@ 2、將 /root/.ssh/id_rsa.pub改名為/root/.ssh/authorized_keys [root@ .ssh]#mv /root/.ssh/id_rsa.pub /root/.ssh/authorized_keys 3、將私鑰id_rsa拷貝到遠程客戶端 1)、如果遠程客戶端是linux，拷貝到遠程客戶端/root/.ssh/即可 2)、putty作為遠程客戶端在 putty不能識別直接從伺服器拷貝來的私鑰，需要使用puttygen.exe進行格式轉換 (1)、打開puttygen.exe --> Conversions --> Import Key (2)、選擇拷貝過來的私鑰文件id_rsa (3)、Save private key->id_rsa.ppk(保存私鑰) 4、打開putty.exe 1)、Session --> Host Name (填寫伺服器地址或者域名) 2)、Connection --> SSH --> Auth (點Browse選擇剛生成的id_rsa.ppk) 3)、open 成功打開後出現如下提示： login as: root Authenticating with public key "imported-openssh-key" ---------------------------------------------------------------------------------- 當然你有可能會遇到這個錯誤 [因為我遇到了，呵呵]： Permissions 0755 for '你配置的公鑰文件路徑' are too open. 這個是因為這幾個文件許可權設置的有點問題 執行命令： chmod 600 你的文件
⑼ RSA 加密演算法（原理篇）
前幾天看到一句話，「我們中的很多人把一生中最燦爛的笑容大部分都獻給了手機和電腦屏幕」。心中一驚，這說明了什麼？手機和電腦已經成為了我們生活中的一部分，所以才會有最懂你的不是你，也不是你男朋友，而是大數據。
如此重要的個人數據，怎樣才能保證其在互聯網上的安全傳輸呢？當然要靠各種加密演算法。說起加密演算法，大家都知道有哈希、對稱加密和非對稱加密了。哈希是一個散列函數，具有不可逆操作；對稱加密即加密和解密使用同一個密鑰，而非對稱加密加密和解密自然就是兩個密鑰了。稍微深入一些的，還要說出非對稱加密演算法有DES、3DES、RC4等，非對稱加密演算法自然就是RSA了。那麼當我們聊起RSA時，我們又在聊些什麼呢？今天筆者和大家一起探討一下，有不足的地方，還望各位朋友多多提意見，共同進步。
RSA簡介：1976年由麻省理工學院三位數學家共同提出的，為了紀念這一里程碑式的成就，就用他們三個人的名字首字母作為演算法的命名。即 羅納德·李維斯特 （Ron Rivest）、 阿迪·薩莫爾 （Adi Shamir）和 倫納德·阿德曼 （Leonard Adleman）。
公鑰：用於加密，驗簽。
私鑰：解密，加簽。
通常知道了公鑰和私鑰的用途以後，即可滿足基本的聊天需求了。但是我們今天的主要任務是來探究一下RSA加解密的原理。
說起加密演算法的原理部分，肯定與數學知識脫不了關系。
我們先來回憶幾個數學知識：
φn = φ(A*B)=φ(A)*φ(B)=(A-1)*(B-1)。
這個公式主要是用來計算給定一個任意的正整數n，在小於等於n的正整數中，有多少個與n構成互質的關系。
其中n=A*B，A與B互為質數，但A與B本身並不要求為質數，可以繼續展開，直至都為質數。
在最終分解完成後，即 φ(N) = φ(p1)*φ(p2)*φ(p3)... 之後，p1，p2，p3都是質數。又用到了歐拉函數的另一個特點，即當p是質數的時候，φp = p - 1。所以有了上面給出的歐拉定理公式。
舉例看一下：
計算15的歐拉函數，因為15比較小，我們可以直接看一下，小於15的正整數有 1、2、3、4、5、6、7、8、9、10、11、12、13、14。和15互質的數有1、2、4、7、8、11、13、14一共四個。
對照我們剛才的歐拉定理： 。
其他感興趣的，大家可以自己驗證。
之所以要在這里介紹歐拉函數，我們在計算公鑰和私鑰時候，會用到。
如果兩個正整數m 和 n 互質，那麼m 的 φn 次方減1，可以被n整除。
其中 .
其中當n為質數時，那麼 上面看到的公式就變成了
mod n 1.
這個公式也就是著名的 費馬小定理 了。
如果兩個正整數e和x互為質數，那麼一定存在一個整數d，不止一個，使得 e*d - 1 可以被x整除，即 e * d mode x 1。則稱 d 是 e 相對於 x的模反元素。
了解了上面所講的歐拉函數、歐拉定理和模反元素後，就要來一些化學反應了，請看圖：
上面這幅圖的公式變化有沒有沒看明白的，沒看明白的咱們評論區見哈。
最終我們得到了最重要的第5個公式的變形，即紅色箭頭後面的：
mod n m。
其中有幾個關系，需要搞明白，m 與 n 互為質數，φn = x，d 是e相對於x的模反元素。
有沒有看到一些加解密的雛形。
從 m 到 m。 這中間涵蓋了從加密到解密的整個過程，但是缺少了我們想要的密文整個過程。
OK，下面引入本文的第四個數學公式：
我們來看一下整個交換流程：
1、客戶端有一個數字13，服務端有一個數字15;
2、客戶端通過計算 3的13次方 對 17 取余，得到數字12; 將12發送給服務端；同時服務端通過計算3的15次方，對17取余，得到數字6，將6發送給客戶端。至此，整個交換過程完成。
3、服務端收到數字12以後，繼續計算，12的15次方 對 17取余，得到 數字10。
4、客戶端收到數字 6以後，繼續計算，6的13次方 對 17 取余，得到數字 10。
有沒有發現雙方，最終得到了相同的內容10。但是這個數字10從來沒有在網路過程中出現過。
好，講到這里，可能有些人已經恍然大悟，這就是加密過程了，但是也有人會產生疑問，為什麼要取數字3 和 17 呢，這里還牽涉到另一個數學知識，原根的問題。即3是17的原根。看圖
有沒有發現規律，3的1~16次方，對17取余，得到的整數是從1~16。這時我們稱3為17的原根。也就是說上面的計算過程中有一組原根的關系。這是最早的迪菲赫爾曼秘鑰交換演算法。
解決了為什麼取3和17的問題後，下面繼續來看最終的RSA是如何產生的：
還記得我們上面提到的歐拉定理嗎，其中 m 與 n 互為質數，n為質數，d 是 e 相對於 φn的模反元素。
當迪菲赫爾曼密鑰交換演算法碰上歐拉定理會產生什麼呢？
我們得到下面的推論：
好，到這里我們是不是已經看到了整個的加密和解密過程了。
其中 m 是明文；c 是密文； n 和 e 為公鑰；d 和 n 為私鑰 。
其中幾組數字的關系一定要明確：
1、d是e 相對於 φn 的模反元素，φn = n-1，即 e * d mod n = 1.
2、m 小於 n，上面在講迪菲赫爾曼密鑰交換演算法時，提到原根的問題，在RSA加密演算法中，對m和n並沒有原根條件的約束。只要滿足m與n互為質數，n為質數，且m < n就可以了。
OK，上面就是RSA加密演算法的原理了，經過上面幾個數學公式的狂轟亂炸，是不是有點迷亂了，給大家一些時間理一下，後面會和大家一起來驗證RSA演算法以及RSA為什麼安全。