rsa加密位長

❶ 加密基礎知識二 非對稱加密RSA演算法和對稱加密

上述過程中，出現了公鑰(3233,17)和私鑰(3233,2753)，這兩組數字是怎麼找出來的呢？參考 RSA演算法原理（二）
首字母縮寫說明：E是加密（Encryption）D是解密（Decryption）N是數字（Number）。

1.隨機選擇兩個不相等的質數p和q。
alice選擇了61和53。（實際應用中，這兩個質數越大，就越難破解。）

2.計算p和q的乘積n。
n = 61×53 = 3233
n的長度就是密鑰長度。3233寫成二進制是110010100001，一共有12位，所以這個密鑰就是12位。實際應用中，RSA密鑰一般是1024位，重要場合則為2048位。

3.計算n的歐拉函數φ(n)。稱作L
根據公式φ(n) = (p-1)(q-1)
alice算出φ(3233)等於60×52，即3120。

4.隨機選擇一個整數e，也就是公鑰當中用來加密的那個數字
條件是1< e < φ(n)，且e與φ(n) 互質。
alice就在1到3120之間，隨機選擇了17。（實際應用中，常常選擇65537。）

5.計算e對於φ(n)的模反元素d。也就是密鑰當中用來解密的那個數字
所謂"模反元素"就是指有一個整數d，可以使得ed被φ(n)除的余數為1。ed ≡ 1 (mod φ(n))
alice找到了2753，即17*2753 mode 3120 = 1

6.將n和e封裝成公鑰，n和d封裝成私鑰。
在alice的例子中，n=3233，e=17，d=2753，所以公鑰就是 (3233,17)，私鑰就是（3233, 2753）。

上述故事中，blob為了偷偷地傳輸移動位數6，使用了公鑰做加密，即6^17 mode 3233 = 824。alice收到824之後，進行解密，即824^2753 mod 3233 = 6。也就是說，alice成功收到了blob使用的移動位數。

再來復習一下整個流程：
p=17,q=19
n = 17 19 = 323
L = 16 18 = 144
E = 5(E需要滿足以下兩個條件：1<E<144,E和144互質)
D = 29(D要滿足兩個條件，1<D<144,D mode 144 = 1)
假設某個需要傳遞123，則加密後：123^5 mode 323 = 225
接收者收到225後，進行解密，225^ 29 mode 323 = 123

回顧上面的密鑰生成步驟，一共出現六個數字：
p
q
n
L即φ(n)
e
d
這六個數字之中，公鑰用到了兩個（n和e），其餘四個數字都是不公開的。其中最關鍵的是d，因為n和d組成了私鑰，一旦d泄漏，就等於私鑰泄漏。那麼，有無可能在已知n和e的情況下，推導出d？
（1）ed≡1 (mod φ(n))。只有知道e和φ(n)，才能算出d。
（2）φ(n)=(p-1)(q-1)。只有知道p和q，才能算出φ(n)。
（3）n=pq。只有將n因數分解，才能算出p和q。
結論：如果n可以被因數分解，d就可以算出，也就意味著私鑰被破解。
可是，大整數的因數分解，是一件非常困難的事情。目前，除了暴力破解，還沒有發現別的有效方法。維基網路這樣寫道："對極大整數做因數分解的難度決定了RSA演算法的可靠性。換言之，對一極大整數做因數分解愈困難，RSA演算法愈可靠。假如有人找到一種快速因數分解的演算法，那麼RSA的可靠性就會極度下降。但找到這樣的演算法的可能性是非常小的。今天只有短的RSA密鑰才可能被暴力破解。到2008年為止，世界上還沒有任何可靠的攻擊RSA演算法的方式。只要密鑰長度足夠長，用RSA加密的信息實際上是不能被解破的。"

然而，雖然RSA的安全性依賴於大數的因子分解，但並沒有從理論上證明破譯RSA的難度與大數分解難度等價。即RSA的重大缺陷是無法從理論上把握它的保密性能如何。此外，RSA的缺點還有：
A)產生密鑰很麻煩，受到素數產生技術的限制，因而難以做到一次一密。
B)分組長度太大，為保證安全性，n 至少也要 600bits以上，使運算代價很高，尤其是速度較慢，較對稱密碼演算法慢幾個數量級；且隨著大數分解技術的發展，這個長度還在增加，不利於數據格式的標准化。因此， 使用RSA只能加密少量數據，大量的數據加密還要靠對稱密碼演算法 。

加密和解密是自古就有技術了。經常看到偵探電影的橋段，勇敢又機智的主角，拿著一長串毫無意義的數字苦惱，忽然靈光一閃，翻出一本厚書，將第一個數字對應頁碼數，第二個數字對應行數，第三個數字對應那一行的某個詞。數字變成了一串非常有意義的話：
Eat the beancurd with the peanut. Taste like the ham.

這種加密方法是將原來的某種信息按照某個規律打亂。某種打亂的方式就叫做密鑰(cipher code)。發出信息的人根據密鑰來給信息加密，而接收信息的人利用相同的密鑰，來給信息解密。 就好像一個帶鎖的盒子。發送信息的人將信息放到盒子里，用鑰匙鎖上。而接受信息的人則用相同的鑰匙打開。加密和解密用的是同一個密鑰，這種加密稱為對稱加密（symmetric encryption）。

如果一對一的話，那麼兩人需要交換一個密鑰。一對多的話，比如總部和多個特工的通信，依然可以使用同一套密鑰。 但這種情況下，對手偷到一個密鑰的話，就知道所有交流的信息了。 二戰中盟軍的情報戰成果，很多都來自於破獲這種對稱加密的密鑰。

為了更安全，總部需要給每個特工都設計一個不同的密鑰。如果是FBI這樣龐大的機構，恐怕很難維護這么多的密鑰。在現代社會，每個人的信用卡信息都需要加密。一一設計密鑰的話，銀行怕是要跪了。

對稱加密的薄弱之處在於給了太多人的鑰匙。如果只給特工鎖，而總部保有鑰匙，那就容易了。特工將信息用鎖鎖到盒子里，誰也打不開，除非到總部用唯一的一把鑰匙打開。只是這樣的話，特工每次出門都要帶上許多鎖，太容易被識破身份了。總部老大想了想，乾脆就把造鎖的技術公開了。特工，或者任何其它人，可以就地取材，按照圖紙造鎖，但無法根據圖紙造出鑰匙。鑰匙只有總部的那一把。

上面的關鍵是鎖和鑰匙工藝不同。知道了鎖，並不能知道鑰匙。這樣，銀行可以將「造鎖」的方法公布給所有用戶。 每個用戶可以用鎖來加密自己的信用卡信息。即使被別人竊聽到，也不用擔心：只有銀行才有鑰匙呢！這樣一種加密演算法叫做非對稱加密(asymmetric encryption)。非對稱加密的經典演算法是RSA演算法。它來自於數論與計算機計數的奇妙結合。

1976年，兩位美國計算機學家Whitfield Diffie 和 Martin Hellman，提出了一種嶄新構思，可以在不直接傳遞密鑰的情況下，完成解密。這被稱為"Diffie-Hellman密鑰交換演算法"。這個演算法啟發了其他科學家。人們認識到，加密和解密可以使用不同的規則，只要這兩種規則之間存在某種對應關系即可，這樣就避免了直接傳遞密鑰。這種新的加密模式被稱為"非對稱加密演算法"。

1977年，三位數學家Rivest、Shamir 和 Adleman 設計了一種演算法，可以實現非對稱加密。這種演算法用他們三個人的名字命名，叫做RSA演算法。從那時直到現在，RSA演算法一直是最廣為使用的"非對稱加密演算法"。毫不誇張地說，只要有計算機網路的地方，就有RSA演算法。

1.能「撞」上的保險箱（非對稱/公鑰加密體制，Asymmetric / Public Key Encryption）

數據加密解密和門鎖很像。最開始的時候，人們只想到了那種只能用鑰匙「鎖」數據的鎖。如果在自己的電腦上自己加密數據，當然可以用最開始這種門鎖的形式啦，方便快捷，簡單易用有木有。

但是我們現在是通信時代啊，雙方都想做安全的通信怎麼辦呢？如果也用這種方法，通信就好像互相發送密碼保險箱一樣…而且雙方必須都有鑰匙才能進行加密和解密。也就是說，兩個人都拿著保險箱的鑰匙，你把數據放進去，用鑰匙鎖上發給我。我用同樣的鑰匙把保險箱打開，再把我的數據鎖進保險箱，發送給你。

這樣看起來好像沒什麼問題。但是，這裡面 最大的問題是：我們兩個怎麼弄到同一個保險箱的同一個鑰匙呢？ 好像僅有的辦法就是我們兩個一起去買個保險箱，然後一人拿一把鑰匙，以後就用這個保險箱了。可是，現代通信社會，絕大多數情況下別說一起去買保險箱了，連見個面都難，這怎麼辦啊？

於是，人們想到了「撞門」的方法。我這有個可以「撞上」的保險箱，你那裡自己也買一個這樣的保險箱。通信最開始，我把保險箱打開，就這么開著把保險箱發給你。你把數據放進去以後，把保險箱「撞」上發給我。撞上以後，除了我以外，誰都打不開保險箱了。這就是RSA了，公開的保險箱就是公鑰，但是我有私鑰，我才能打開。

2.數字簽名
這種鎖看起來好像很不錯，但是鎖在運輸的過程中有這么一個嚴重的問題：你怎麼確定你收到的開著的保險箱就是我發來的呢？對於一個聰明人，他完全可以這么干：
(a)裝作運輸工人。我現在把我開著的保險箱運給對方。運輸工人自己也弄這么一個保險箱，運輸的時候把保險箱換成他做的。
(b)對方收到保險箱後，沒法知道這個保險箱是我最初發過去的，還是運輸工人替換的。對方把數據放進去，把保險箱撞上。
(c)運輸工人往回運的時候，用自己的鑰匙打開自己的保險箱，把數據拿走。然後復印也好，偽造也好，弄出一份數據，把這份數據放進我的保險箱，撞上，然後發給我。
從我的角度，從對方的角度，都會覺得這數據傳輸過程沒問題。但是，運輸工人成功拿到了數據，整個過程還是不安全的，大概的過程是這樣：

這怎麼辦啊？這個問題的本質原因是，人們沒辦法獲知，保險箱到底是「我」做的，還是運輸工人做的。那乾脆，我們都別做保險箱了，讓權威機構做保險箱，然後在每個保險箱上用特殊的工具刻上一個編號。對方收到保險箱的時候，在權威機構的「公告欄」上查一下編號，要是和保險箱上的編號一樣，我就知道這個保險箱是「我」的，就安心把數據放進去。大概過程是這樣的：

如何做出刻上編號，而且編號沒法修改的保險箱呢？這涉及到了公鑰體制中的另一個問題：數字簽名。
要知道，刻字這種事情吧，誰都能幹，所以想做出只能自己刻字，還沒法讓別人修改的保險箱確實有點難度。那麼怎麼辦呢？這其實困擾了人們很長的時間。直到有一天，人們發現：我們不一定非要在保險箱上刻規規矩矩的字，我們乾脆在保險箱上刻手寫名字好了。而且，刻字有點麻煩，乾脆我們在上面弄張紙，讓人直接在上面寫，簡單不費事。具體做法是，我們在保險箱上嵌進去一張紙，然後每個出產的保險箱都讓權威機構的CEO簽上自己的名字。然後，CEO把自己的簽名公開在權威機構的「公告欄」上面。比如這個CEO就叫「學酥」，那麼整個流程差不多是這個樣子：

這個方法的本質原理是，每個人都能夠通過筆跡看出保險箱上的字是不是學酥CEO簽的。但是呢，這個字體是學酥CEO唯一的字體。別人很難模仿。如果模仿我們就能自己分辨出來了。要是實在分辨不出來呢，我們就請一個筆跡專家來分辨。這不是很好嘛。這個在密碼學上就是數字簽名。

上面這個簽字的方法雖然好，但是還有一個比較蛋疼的問題。因為簽字的樣子是公開的，一個聰明人可以把公開的簽字影印一份，自己造個保險箱，然後把這個影印的字也嵌進去。這樣一來，這個聰明人也可以造一個相同簽字的保險箱了。解決這個問題一個非常簡單的方法就是在看保險箱上的簽名時，不光看字體本身，還要看字體是不是和公開的字體完全一樣。要是完全一樣，就可以考慮這個簽名可能是影印出來的。甚至，還要考察字體是不是和其他保險櫃上的字體一模一樣。因為聰明人為了欺騙大家，可能不影印公開的簽名，而影印其他保險箱上的簽名。這種解決方法雖然簡單，但是驗證簽名的時候麻煩了一些。麻煩的地方在於我不僅需要對比保險箱上的簽名是否與公開的筆跡一樣，還需要對比得到的簽名是否與公開的筆跡完全一樣，乃至是否和所有發布的保險箱上的簽名完全一樣。有沒有什麼更好的方法呢？

當然有，人們想到了一個比較好的方法。那就是，學酥CEO簽字的時候吧，不光把名字簽上，還得帶上簽字得日期，或者帶上這個保險箱的編號。這樣一來，每一個保險箱上的簽字就唯一了，這個簽字是學酥CEO的簽名+學酥CEO寫上的時間或者編號。這樣一來，就算有人偽造，也只能偽造用過的保險箱。這個問題就徹底解決了。這個過程大概是這么個樣子：

3 造價問題（密鑰封裝機制，Key Encapsulation Mechanism）
解決了上面的各種問題，我們要考慮考慮成本了… 這種能「撞」門的保險箱雖然好，但是這種鎖造價一般來說要比普通的鎖要高，而且鎖生產時間也會變長。在密碼學中，對於同樣「結實」的鎖，能「撞」門的鎖的造價一般來說是普通鎖的上千倍。同時，能「撞」門的鎖一般來說只能安裝在小的保險櫃裡面。畢竟，這么復雜的鎖，裝起來很費事啊！而普通鎖安裝在多大的保險櫃上面都可以呢。如果兩個人想傳輸大量數據的話，用一個大的保險櫃比用一堆小的保險櫃慢慢傳要好的多呀。怎麼解決這個問題呢？人們又想出了一個非常棒的方法：我們把兩種鎖結合起來。能「撞」上的保險櫃裡面放一個普通鎖的鑰匙。然後造一個用普通的保險櫃來鎖大量的數據。這樣一來，我們相當於用能「撞」上的保險櫃發一個鑰匙過去。對方收到兩個保險櫃後，先用自己的鑰匙把小保險櫃打開，取出鑰匙。然後在用這個鑰匙開大的保險櫃。這樣做更棒的一個地方在於，既然對方得到了一個鑰匙，後續再通信的時候，我們就不再需要能「撞」上的保險櫃了啊，在以後一定時間內就用普通保險櫃就好了，方便快捷嘛。

以下參考 數字簽名、數字證書、SSL、https是什麼關系？
4.數字簽名（Digital Signature）
數據在瀏覽器和伺服器之間傳輸時，有可能在傳輸過程中被冒充的盜賊把內容替換了，那麼如何保證數據是真實伺服器發送的而不被調包呢，同時如何保證傳輸的數據沒有被人篡改呢，要解決這兩個問題就必須用到數字簽名，數字簽名就如同日常生活的中的簽名一樣，一旦在合同書上落下了你的大名，從法律意義上就確定是你本人簽的字兒，這是任何人都沒法仿造的，因為這是你專有的手跡，任何人是造不出來的。那麼在計算機中的數字簽名怎麼回事呢？數字簽名就是用於驗證傳輸的內容是不是真實伺服器發送的數據，發送的數據有沒有被篡改過，它就干這兩件事，是非對稱加密的一種應用場景。不過他是反過來用私鑰來加密，通過與之配對的公鑰來解密。
第一步：服務端把報文經過Hash處理後生成摘要信息Digest，摘要信息使用私鑰private-key加密之後就生成簽名，伺服器把簽名連同報文一起發送給客戶端。
第二步：客戶端接收到數據後，把簽名提取出來用public-key解密，如果能正常的解密出來Digest2，那麼就能確認是對方發的。
第三步：客戶端把報文Text提取出來做同樣的Hash處理，得到的摘要信息Digest1，再與之前解密出來的Digist2對比，如果兩者相等，就表示內容沒有被篡改，否則內容就是被人改過了。因為只要文本內容哪怕有任何一點點改動都會Hash出一個完全不一樣的摘要信息出來。

5.數字證書（Certificate Authority）
數字證書簡稱CA，它由權威機構給某網站頒發的一種認可憑證，這個憑證是被大家（瀏覽器）所認可的，為什麼需要用數字證書呢，難道有了數字簽名還不夠安全嗎？有這樣一種情況，就是瀏覽器無法確定所有的真實伺服器是不是真的是真實的，舉一個簡單的例子：A廠家給你們家安裝鎖，同時把鑰匙也交給你，只要鑰匙能打開鎖，你就可以確定鑰匙和鎖是配對的，如果有人把鑰匙換了或者把鎖換了，你是打不開門的，你就知道肯定被竊取了，但是如果有人把鎖和鑰匙替換成另一套表面看起來差不多的，但質量差很多的，雖然鑰匙和鎖配套，但是你卻不能確定這是否真的是A廠家給你的，那麼這時候，你可以找質檢部門來檢驗一下，這套鎖是不是真的來自於A廠家，質檢部門是權威機構，他說的話是可以被公眾認可的（呵呵）。
同樣的， 因為如果有人（張三）用自己的公鑰把真實伺服器發送給瀏覽器的公鑰替換了，於是張三用自己的私鑰執行相同的步驟對文本Hash、數字簽名，最後得到的結果都沒什麼問題，但事實上瀏覽器看到的東西卻不是真實伺服器給的，而是被張三從里到外（公鑰到私鑰）換了一通。那麼如何保證你現在使用的公鑰就是真實伺服器發給你的呢？我們就用數字證書來解決這個問題。數字證書一般由數字證書認證機構（Certificate Authority）頒發，證書裡麵包含了真實伺服器的公鑰和網站的一些其他信息，數字證書機構用自己的私鑰加密後發給瀏覽器，瀏覽器使用數字證書機構的公鑰解密後得到真實伺服器的公鑰。這個過程是建立在被大家所認可的證書機構之上得到的公鑰，所以這是一種安全的方式。

常見的對稱加密演算法有DES、3DES、AES、RC5、RC6。非對稱加密演算法應用非常廣泛，如SSH,
HTTPS, TLS，電子證書，電子簽名，電子身份證等等。
參考 DES/3DES/AES區別

❷ 電腦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中pkcs1的填充方法具體是什麼

1）RSA_PKCS1_PADDING 填充模式，最常用的模式

要求:
輸入 必須 比 RSA 鑰模長(molus) 短至少11個位元組, 也就是 RSA_size(rsa) – 11
如果輸入的明文過長，必須切割， 然後填充

輸出 和molus一樣長

根據這個要求，對於512bit的密鑰， block length = 512/8 – 11 = 53 位元組

2） RSA_PKCS1_OAEP_PADDING
RSA_size(rsa) – 41

3）for RSA_NO_PADDING 不填充
RSA_size(rsa)

一般來說， 我們只用RSA來加密重要的數據，比如AES的key, 128bits = 16

加密的輸出，總是等於key length

對同樣的數據，用同樣的key進行RSA加密， 每次的輸出都會不一樣； 但是這些加密的結果都能正確的解密
—————
預備知識
I2OSP – Integer-to-Octet-String primitive 大整數轉換成位元組串
I2OSP (x, xLen)
輸入: x 待轉換的非負整數
xLen 結果位元組串的可能長度

————
加密原理 RSAEP ((n, e), m)
輸入: (n,e) RSA公鑰
m 值為0到n-1 之間一個大整數，代表消息
輸出: c 值為0到n-1之間的一個大整數，代表密文
假定： RSA公鑰(n,e)是有效的
步驟：
1. 如果m不滿足 0 2. 讓 c = m^e % n (m的e次冪 除以n ,余數為c)
3. 輸出 c

解密原理 RSADP (K, c)
輸入： K RSA私鑰，K由下面形式：
一對(n,d)
一個五元組(p, q, dP, dQ, qInv)
一個可能為空的三元序列(ri, di, ti), i=3,...,u
c 密文
輸出： m 明文

步驟：
1. 如果密文c不滿足 0 < c < n-1, 輸出 'ciphertext repersentative out of range'
2. 按照如下方法計算m:
a. 如果使用私鑰K的第一種形式(n, d), 就讓 m = c^d % n (c的d次冪，除以n,余數為m)
b. 如果使用私鑰K的第二種像是(p,q, dP, dQ, qInv)和(ri, di, ti),
--------------

----------------
加密 RSAES-PKCS1-V1_5-ENCRYPT ((n, e), M)

輸入： (n, e) 接收者的公開鑰匙， k表示n所佔用的位元組長度
M 要加密的消息， mLen表示消息的長度 mLen ≤ k – 11

輸出： C 密文， 佔用位元組數 也為 k

步驟：
1.長度檢查， 如果 mLen > k-11, 輸出 逗message too long地

2. EME-PKCS1-v1_5 編碼
a) 生成一個 偽隨機非零串PS ， 長度為 k – mLen – 3， 所以至少為8， 因為 k-mLen>11
b) 將PS， M，以及其他填充串 一起編碼為 EM， 長度為 k, 即:
EM = 0×00 || 0×02 || PS || 0×00 || M

3.RSA 加密
a)將EM轉換成一個大證書m
m = OS2IP(EM)

b)對公鑰(n,e) 和 大整數 m, 使用RSAEP加密原理，產生一個整數密文c
c = RSAEP((n,e0, m)

c)將整數c轉換成長度為k的密文串
C = I2OSP(c, k)

4.輸出密文C
—————-
解密 RSAES-PKCS1-V1_5-DECRYPT (K, C)

輸入： K 接收者的私鑰
C 已經加密過的密文串，長度為k (與RSA molus n的長度一樣）
輸出： M 消息明文， 長度至多為 k-11

步驟：
1. 長度檢查：如果密文C的長度不為k位元組（或者 如果 k<11), 輸出逗decryption error"

2. RSA解密
a. 轉換密文C為一個大整數c
c = OS2IP(C)
b. 對RSA私鑰(n,d)和密文整數c 實施解密， 產生一個 大整數m
m = RSADP((n,d), c)
如果RSADP輸出'ciphertext representative out of range'(意味c>=n), 就輸出』decryption error地
c. 轉換 m 為長度為k的EM串
EM = I2OSP(m, k)
3. EME-PKCS1-v1_5 解碼：將EM分為 非零的PS串 和 消息 M
EM = 0×00 || 0×02 || PS || 0×00 || M
如果EM不是上面給出的格式，或者PS的長度小於8個位元組， 那麼就輸出』decryption error』

5. 輸出明文消息M

——————–
簽名 RSASSA-PSS-SIGN (K, M)
輸入 K 簽名者的RSA私鑰
M 代簽名的消息，一個位元組串
輸出 S 簽名，長度為k的位元組串，k是RSA molus n的位元組長度

步驟:
1. EMSA-PSS encoding: 對消息M實施EMSA-PSS編碼操作，產生一個長度為 [(modBits -1)/8]的編碼消息EM。 整數 OS2IP(EM)的位長最多是 modBits-1, modBits是RSA molus n的位長度
EM = EMSA-PSS-ENCODE (M, modBits – 1)

注意：如果modBits-1 能被8整除，EM的位元組長比k小1；否則EM位元組長為k

2. RSA簽名:
a. 將編碼後的消息 EM 轉換成一個大整數m
m = OS2IP(EM)
b. 對私鑰K和消息m 實施 RSASP1 簽名，產生一個 大整數s表示的簽名
s = RSASP1 (K, m)
c. 把大整數s轉換成 長度為k的字串簽名S
S = I2OSP(s, k)
3.輸出簽名S
———–
驗證簽名 RSASSA-PSS-VERIFY ((n, e), M, S)
輸入： (n,e) 簽名者的公鑰
M 簽名者 發來的消息，一個字串
S 待驗證的簽名， 一個長度為k的字串。k是RSA Molus n的長度
輸出： 』valid signature』 或者 『invalid signature』
步驟：
1. 長度檢查: 如果簽名S的長度不是k, 輸出』invalid signature』

2. RSA驗證
a) 將簽名S轉換成一個大整數s
s = OS2IP (S)
b) 對公鑰 (n,e) 和 s 實施 RSAVP1 驗證， 產生一個 大整數m
m = RSAVP1 ((n, e), s)
c) 將m 轉換成編碼的消息EM,長度 emLen = [ (modBits -1)/8 ] 位元組。 modBits是RSA molus n的位長
EM = I2OSP (m, emLen)
注意： 如果 modBits-1可以被8整除，那麼emLen = k-1,否則 emLen = k

3. EMSA-PSS驗證： 對消息M和編碼的EM實施一個 EMSA-PSS驗證操作，決定他們是否一致：
Result = EMSA-PSS-VERIFY (M, EM, modBits – 1)

4. 如果Result = 逗consistent逗，那麼輸出 地valid signature地
否則， 輸出 地invalid signature地

———–
簽名，還可以使用 EMSA-PKCS1-v1_5 encoding編碼方法 來產生 EM:
EM = EMSA-PKCS1-V1_5-ENCODE (M, k)

驗證簽名是，使用 EMSA-PKCS1-v1_5對 M產生第2個編碼消息EM』
EM』 = EMSA-PKCS1-V1_5-ENCODE (M, k) .

然後比較 EM和EM』 是否相同

———————

RSA的加密機制有兩種方案一個是RSAES-OAEP，另一個RSAES-PKCS1-v1_5。PKCS#1推薦在新的應用中使用RSAES- OAEP，保留RSAES-PKCS#1-v1_5跟老的應用兼容。它們兩的區別僅僅在於加密前編碼的方式不同。而加密前的編碼是為了提供了抵抗各種活動的敵對攻擊的安全機制。

PKCS#1的簽名機制也有種方案：RSASSA-PSS和RSASSA-PKCS1-v1_5。同樣，推薦RSASSA-PSS用於新的應用而RSASSA-PKCS1-v1_5用於兼容老的應用。

——————–

RSAES-OAEP-ENCRYPT ((n, e), M, L)
選項： Hash 散列函數(hLen 表示 散列函數的輸出的位元組串的長度）
MGF 掩碼生成函數
輸入: (n,e) 接收者的RSA公鑰(k表示RSA molus n的位元組長度）
M 待加密的消息，一個長度為mLen的位元組串 mLen <= k - 2 hLen -2
L 同消息關聯的可選的標簽，如果不提供L，就採用空串
輸出: C 密文，位元組長度為k
步驟：
1.長度檢查
a. 如果L的長度超過 hash函數的輸入限制(對於SHA-1, 是2^61 -1），輸出 label too long
b. mLen > k – 2hLen -2, 輸出 message too long
2. EME-OAEP編碼

說實話，我看了很久不太懂。。。。。。。

❹ 所謂的1024位RSA密鑰長度，是指1個數還是2個數

這是二進制數字的計數單位，1024位(bit)中的位是二進制中最小的單元,比如「0001」這是四位，「0001 0010「這種就是8位了」,1位元組(Byte)=8位(bit)。128位元組等於1028位。

❺ DES的密鑰長度是幾位RSA的密鑰長度是幾位

RSA一般達到二進制512位,高的也有2048位的,要用到大數

❻ 有關C#中RSA加密方法的密鑰生成長度

/// <summary> /// 字元串加密操作類
/// </summary>
public class EncryptionOperation
{
/// <summary>

/// MD5 加密靜態方法
/// </summary>
/// <param name="EncryptString">待加密的密文</param>
/// <returns>returns</returns>
public static string MD5Encrypt(string EncryptString) {
if (string.IsNullOrEmpty(EncryptString)) { throw (new Exception("密文不得為空")); }

MD5 m_ClassMD5 = new MD5CryptoServiceProvider();

string m_strEncrypt = "";

try {
m_strEncrypt = BitConverter.ToString(m_ClassMD5.ComputeHash(Encoding.Default.GetBytes(EncryptString))).Replace("-", "");
}
catch (ArgumentException ex) { throw ex; }
catch (CryptographicException ex) { throw ex; }
catch (Exception ex) { throw ex; }
finally { m_ClassMD5.Clear(); }

return m_strEncrypt;
}

/// <summary>
/// DES 加密(數據加密標准，速度較快，適用於加密大量數據的場合)
/// </summary>
/// <param name="EncryptString">待加密的密文</param>
/// <param name="EncryptKey">加密的密鑰</param>
/// <returns>returns</returns>
public static string DESEncrypt(string EncryptString, string EncryptKey) {
if (string.IsNullOrEmpty(EncryptString)) { throw (new Exception("密文不得為空")); }

if (string.IsNullOrEmpty(EncryptKey)) { throw (new Exception("密鑰不得為空")); }

if (EncryptKey.Length != 8) { throw (new Exception("密鑰必須為8位")); }

byte[] m_btIV = { 0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF };

string m_strEncrypt = "";

DESCryptoServiceProvider m_DESProvider = new DESCryptoServiceProvider();

try {
byte[] m_btEncryptString = Encoding.Default.GetBytes(EncryptString);

MemoryStream m_stream = new MemoryStream();

CryptoStream m_cstream = new CryptoStream(m_stream, m_DESProvider.CreateEncryptor(Encoding.Default.GetBytes(EncryptKey), m_btIV), CryptoStreamMode.Write);

m_cstream.Write(m_btEncryptString, 0, m_btEncryptString.Length);

m_cstream.FlushFinalBlock();

m_strEncrypt = Convert.ToBase64String(m_stream.ToArray());

m_stream.Close(); m_stream.Dispose();

m_cstream.Close(); m_cstream.Dispose();
}
catch (IOException ex) { throw ex; }
catch (CryptographicException ex) { throw ex; }
catch (ArgumentException ex) { throw ex; }
catch (Exception ex) { throw ex; }
finally { m_DESProvider.Clear(); }

return m_strEncrypt;
}
/// <summary>
/// DES 解密(數據加密標准，速度較快，適用於加密大量數據的場合)
/// </summary>
/// <param name="DecryptString">待解密的密文</param>
/// <param name="DecryptKey">解密的密鑰</param>
/// <returns>returns</returns>
public static string DESDecrypt(string DecryptString, string DecryptKey) {
if (string.IsNullOrEmpty(DecryptString)) { throw (new Exception("密文不得為空")); }

if (string.IsNullOrEmpty(DecryptKey)) { throw (new Exception("密鑰不得為空")); }

if (DecryptKey.Length != 8) { throw (new Exception("密鑰必須為8位")); }

byte[] m_btIV = { 0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF };

string m_strDecrypt = "";

DESCryptoServiceProvider m_DESProvider = new DESCryptoServiceProvider();

try {
byte[] m_btDecryptString = Convert.FromBase64String(DecryptString);

MemoryStream m_stream = new MemoryStream();

CryptoStream m_cstream = new CryptoStream(m_stream, m_DESProvider.CreateDecryptor(Encoding.Default.GetBytes(DecryptKey), m_btIV), CryptoStreamMode.Write);

m_cstream.Write(m_btDecryptString, 0, m_btDecryptString.Length);

m_cstream.FlushFinalBlock();

m_strDecrypt = Encoding.Default.GetString(m_stream.ToArray());

m_stream.Close(); m_stream.Dispose();

m_cstream.Close(); m_cstream.Dispose();
}
catch (IOException ex) {
m_strDecrypt = "";
}

catch (CryptographicException ex) { m_strDecrypt = ""; }
catch (ArgumentException ex) { m_strDecrypt = ""; }
catch (Exception ex) { m_strDecrypt = ""; }
finally { m_DESProvider.Clear(); }

return m_strDecrypt;
}
/// <summary>
/// RC2 加密(用變長密鑰對大量數據進行加密)
/// </summary>
/// <param name="EncryptString">待加密密文</param>
/// <param name="EncryptKey">加密密鑰</param>
/// <returns>returns</returns>
public static string RC2Encrypt(string EncryptString, string EncryptKey) {
if (string.IsNullOrEmpty(EncryptString)) { throw (new Exception("密文不得為空")); }

if (string.IsNullOrEmpty(EncryptKey)) { throw (new Exception("密鑰不得為空")); }

if (EncryptKey.Length < 5 || EncryptKey.Length > 16) { throw (new Exception("密鑰必須為5-16位")); }

string m_strEncrypt = "";

byte[] m_btIV = { 0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF };

RC2CryptoServiceProvider m_RC2Provider = new RC2CryptoServiceProvider();

try {
byte[] m_btEncryptString = Encoding.Default.GetBytes(EncryptString);

MemoryStream m_stream = new MemoryStream();

CryptoStream m_cstream = new CryptoStream(m_stream, m_RC2Provider.CreateEncryptor(Encoding.Default.GetBytes(EncryptKey), m_btIV), CryptoStreamMode.Write);

m_cstream.Write(m_btEncryptString, 0, m_btEncryptString.Length);

m_cstream.FlushFinalBlock();

m_strEncrypt = Convert.ToBase64String(m_stream.ToArray());

m_stream.Close(); m_stream.Dispose();

m_cstream.Close(); m_cstream.Dispose();
}
catch (IOException ex) { throw ex; }
catch (CryptographicException ex) { throw ex; }
catch (ArgumentException ex) { throw ex; }
catch (Exception ex) { throw ex; }
finally { m_RC2Provider.Clear(); }

return m_strEncrypt;
}
/// <summary>
/// RC2 解密(用變長密鑰對大量數據進行加密)
/// </summary>
/// <param name="DecryptString">待解密密文</param>
/// <param name="DecryptKey">解密密鑰</param>
/// <returns>returns</returns>
public static string RC2Decrypt(string DecryptString, string DecryptKey) {
if (string.IsNullOrEmpty(DecryptString)) { throw (new Exception("密文不得為空")); }

if (string.IsNullOrEmpty(DecryptKey)) { throw (new Exception("密鑰不得為空")); }

if (DecryptKey.Length < 5 || DecryptKey.Length > 16) { throw (new Exception("密鑰必須為5-16位")); }

byte[] m_btIV = { 0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF };

string m_strDecrypt = "";

RC2CryptoServiceProvider m_RC2Provider = new RC2CryptoServiceProvider();

try {
byte[] m_btDecryptString = Convert.FromBase64String(DecryptString);

MemoryStream m_stream = new MemoryStream();

CryptoStream m_cstream = new CryptoStream(m_stream, m_RC2Provider.CreateDecryptor(Encoding.Default.GetBytes(DecryptKey), m_btIV), CryptoStreamMode.Write);

m_cstream.Write(m_btDecryptString, 0, m_btDecryptString.Length);

m_cstream.FlushFinalBlock();

m_strDecrypt = Encoding.Default.GetString(m_stream.ToArray());

m_stream.Close(); m_stream.Dispose();

m_cstream.Close(); m_cstream.Dispose();
}
catch (IOException ex) { throw ex; }
catch (CryptographicException ex) { throw ex; }
catch (ArgumentException ex) { throw ex; }
catch (Exception ex) { throw ex; }
finally { m_RC2Provider.Clear(); }
return m_strDecrypt;
}
/// <summary>
/// 3DES 加密(基於DES，對一塊數據用三個不同的密鑰進行三次加密，強度更高)
/// </summary>
/// <param name="EncryptString">待加密密文</param>
/// <param name="EncryptKey1">密鑰一</param>
/// <param name="EncryptKey2">密鑰二</param>
/// <param name="EncryptKey3">密鑰三</param>
/// <returns>returns</returns>
public static string DES3Encrypt(string EncryptString, string EncryptKey1, string EncryptKey2, string EncryptKey3) {
string m_strEncrypt = "";

try {
m_strEncrypt = DESEncrypt(EncryptString, EncryptKey3);

m_strEncrypt = DESEncrypt(m_strEncrypt, EncryptKey2);

m_strEncrypt = DESEncrypt(m_strEncrypt, EncryptKey1);
}
catch (Exception ex) { throw ex; }

return m_strEncrypt;
}
/// <summary>
/// 3DES 解密(基於DES，對一塊數據用三個不同的密鑰進行三次加密，強度更高)
/// </summary>
/// <param name="DecryptString">待解密密文</param>
/// <param name="DecryptKey1">密鑰一</param>
/// <param name="DecryptKey2">密鑰二</param>
/// <param name="DecryptKey3">密鑰三</param>
/// <returns>returns</returns>
public static string DES3Decrypt(string DecryptString, string DecryptKey1, string DecryptKey2, string DecryptKey3) {
string m_strDecrypt = "";

try {
m_strDecrypt = DESDecrypt(DecryptString, DecryptKey1);

m_strDecrypt = DESDecrypt(m_strDecrypt, DecryptKey2);

m_strDecrypt = DESDecrypt(m_strDecrypt, DecryptKey3);
}
catch (Exception ex) { throw ex; }

return m_strDecrypt;
}
/// <summary>
/// AES 加密(高級加密標准，是下一代的加密演算法標准，速度快，安全級別高，目前 AES 標準的一個實現是 Rijndael 演算法)
/// </summary>
/// <param name="EncryptString">待加密密文</param>
/// <param name="EncryptKey">加密密鑰</param>
/// <returns></returns>
public static string AESEncrypt(string EncryptString, string EncryptKey) {
if (string.IsNullOrEmpty(EncryptString)) { throw (new Exception("密文不得為空")); }

if (string.IsNullOrEmpty(EncryptKey)) { throw (new Exception("密鑰不得為空")); }

string m_strEncrypt = "";

byte[] m_btIV = Convert.FromBase64String("Rkb4jvUy/ye7Cd7k89QQgQ==");

Rijndael m_AESProvider = Rijndael.Create();

try {
byte[] m_btEncryptString = Encoding.Default.GetBytes(EncryptString);

MemoryStream m_stream = new MemoryStream();

CryptoStream m_csstream = new CryptoStream(m_stream, m_AESProvider.CreateEncryptor(Encoding.Default.GetBytes(EncryptKey), m_btIV), CryptoStreamMode.Write);

m_csstream.Write(m_btEncryptString, 0, m_btEncryptString.Length); m_csstream.FlushFinalBlock();

m_strEncrypt = Convert.ToBase64String(m_stream.ToArray());

m_stream.Close(); m_stream.Dispose();

m_csstream.Close(); m_csstream.Dispose();
}
catch (IOException ex) { throw ex; }
catch (CryptographicException ex) { throw ex; }
catch (ArgumentException ex) { throw ex; }
catch (Exception ex) { throw ex; }
finally { m_AESProvider.Clear(); }

return m_strEncrypt;
}
/// <summary>
/// AES 解密(高級加密標准，是下一代的加密演算法標准，速度快，安全級別高，目前 AES 標準的一個實現是 Rijndael 演算法)
/// </summary>
/// <param name="DecryptString">待解密密文</param>
/// <param name="DecryptKey">解密密鑰</param>
/// <returns></returns>
public static string AESDecrypt(string DecryptString, string DecryptKey) {
if (string.IsNullOrEmpty(DecryptString)) { throw (new Exception("密文不得為空")); }

if (string.IsNullOrEmpty(DecryptKey)) { throw (new Exception("密鑰不得為空")); }

string m_strDecrypt = "";

byte[] m_btIV = Convert.FromBase64String("Rkb4jvUy/ye7Cd7k89QQgQ==");

Rijndael m_AESProvider = Rijndael.Create();

try {
byte[] m_btDecryptString = Convert.FromBase64String(DecryptString);

MemoryStream m_stream = new MemoryStream();

CryptoStream m_csstream = new CryptoStream(m_stream, m_AESProvider.CreateDecryptor(Encoding.Default.GetBytes(DecryptKey), m_btIV), CryptoStreamMode.Write);

m_csstream.Write(m_btDecryptString, 0, m_btDecryptString.Length); m_csstream.FlushFinalBlock();

m_strDecrypt = Encoding.Default.GetString(m_stream.ToArray());

m_stream.Close(); m_stream.Dispose();

m_csstream.Close(); m_csstream.Dispose();
}
catch (IOException ex) { throw ex; }
catch (CryptographicException ex) { throw ex; }
catch (ArgumentException ex) { throw ex; }
catch (Exception ex) { throw ex; }
finally { m_AESProvider.Clear(); }

return m_strDecrypt;
} }

❼ 摘抄與理解--RSA加密和ssl

結論：

加密和解密使用同樣規則（簡稱"密鑰"），這被稱為 "對稱加密演算法"

RSA是一種非對稱加密的演算法，為什麼會有這個，先說對成加密，對稱就是同一個密鑰加密解密，不安全，

SSL是基於非對稱加密的原理，在這之上還進行了對稱加密的數據傳輸

對成加密的話：

（1）甲方選擇某一種加密規則，對信息進行加密；

（2）乙方使用同一種規則，對信息進行解密。

因為加密規則是相同的，所以最好是一份數據，或者一個客戶一個密鑰，每個人密鑰不能不能隨便公開

非對稱加密的話：

       （1）乙方生成兩把密鑰（公鑰和私鑰）。公鑰是公開的，任何人都可以獲得，私鑰則是保密的。

（2）甲方獲取乙方的公鑰，然後用它對信息加密。

（3）乙方得到加密後的信息，用私鑰解密。

雖然大家都是用的同一個公鑰加密的，但是只有有密鑰才解得開，隨便你的公鑰怎麼傳播

互質關系

如果兩個正整數，除了1以外，沒有其他公因子，我們就稱這兩個數是 互質關系 （coprime）。比如，15和32沒有公因子，所以它們是互質關系。這說明，不是質數也可以構成互質關系。

關於互質關系，不難得到以下結論：

1. 任意兩個質數構成互質關系，比如13和61。

2. 一個數是質數，另一個數只要不是前者的倍數，兩者就構成互質關系，比如3和10。

3. 如果兩個數之中，較大的那個數是質數，則兩者構成互質關系，比如97和57。

4. 1和任意一個自然數是都是互質關系，比如1和99。

5. p是大於1的整數，則p和p-1構成互質關系，比如57和56。

6. p是大於1的奇數，則p和p-2構成互質關系，比如17和15。

歐拉函數

請思考以下問題：

任意給定正整數n，請問在小於等於n的正整數之中，有多少個與n構成互質關系？（比如，在1到8之中，有多少個數與8構成互質關系？）

計算這個值的方法就叫做 歐拉函數 ，以φ(n)表示。在1到8之中，與8形成互質關系的是1、3、5、7，所以 φ(n) = 4，

我有個蠢的辦法先說說，互質的本質是，兩個數的所有公因子，出了1沒有交集，所以我們可以先求8的所有公因子（1-8除個遍，余數為零的就是他的公因子），然後剩下的1-8，循環一遍，把他們的所有公因子也求出來，對比兩者的公因子除了1以外還有沒有交集，沒有的話，說明兩者互質。

或者就是按照文章里的1-6條規則L一一算一遍

歐拉定理

歐拉函數的用處，在於 歐拉定理 。"歐拉定理"指的是：

如果兩個正整數a和n互質，則n的歐拉函數 φ(n) 可以讓下面的等式成立：

（3（φ(7)） - 1）= 7*104

歐拉定理的證明比較復雜，這里就省略了。我們只要記住它的結論就行了。

歐拉定理可以大大簡化某些運算。比如，7和10互質，根據歐拉定理，

已知 φ(10) 等於4，所以馬上得到7的4倍數次方的個位數肯定是1。

因此，7的任意次方的個位數（例如7的222次方），心算就可以算出來

模反元素

還剩下最後一個概念：

如果兩個正整數a和n互質，那麼一定可以找到整數b，使得 ab-1 被n整除，或者說ab被n除的余數是1。

這時，b就叫做a的 "模反元素" 。

3 * 5 - 1 = 7 * 2 

5就是3的模反元素

密鑰生成的步驟

第一步，隨機選擇兩個不相等的質數p和q。互質

愛麗絲選擇了61和53。（實際應用中，這兩個質數越大，就越難破解。）

第二步，計算p和q的乘積n。

愛麗絲就把61和53相乘。

n = 61×53 = 3233

n的長度就是密鑰長度。3233寫成二進制是110010100001，一共有12位，所以這個密鑰就是12位。實際應用中，RSA密鑰一般是1024位，重要場合則為2048位。

第三步，計算n的歐拉函數φ(n)。

根據公式：

φ(n) = (p-1)(q-1)

愛麗絲算出φ(3233)等於60×52，即3120。

第四步，隨機選擇一個整數e，條件是1< e < φ(n)，且e與φ(n) 互質。

愛麗絲就在1到3120之間，隨機選擇了17。（實際應用中，常常選擇65537。）

第五步，計算e對於φ(n)的模反元素d。

所謂 "模反元素" 就是指有一個整數d，可以使得ed被φ(n)除的余數為1。

ed ≡ 1 (mod φ(n))

這個式子等價於

ed - 1 = kφ(n)

於是，找到模反元素d，實質上就是對下面這個二元一次方程求解。

ex + φ(n)y = 1

已知 e=17, φ(n)=3120，

17x + 3120y = 1

這個方程可以用 "擴展歐幾里得演算法" 求解，此處省略具體過程。總之，愛麗絲算出一組整數解為 (x,y)=(2753,-15)，即 d=2753。

至此所有計算完成。

第六步，將n和e封裝成公鑰，n和d封裝成私鑰。

在愛麗絲的例子中，n=3233，e=17，d=2753，所以公鑰就是 (3233,17)，私鑰就是（3233, 2753）。

實際應用中，公鑰和私鑰的數據都採用 ASN.1 格式表達（ 實例 ）。

七、RSA演算法的可靠性

回顧上面的密鑰生成步驟，一共出現六個數字：

p

q

n

φ(n)

e

d

這六個數字之中，公鑰用到了兩個（n和e），其餘四個數字都是不公開的。其中最關鍵的是d，因為n和d組成了私鑰，一旦d泄漏，就等於私鑰泄漏。

那麼，有無可能在已知n和e的情況下，推導出d？

（1）ed≡1 (mod φ(n))。只有知道e和φ(n)，才能算出d。

（2）φ(n)=(p-1)(q-1)。只有知道p和q，才能算出φ(n)。

（3）n=pq。只有將n因數分解，才能算出p和q。

結論：如果n可以被因數分解，d就可以算出，也就意味著私鑰被破解

加密和解密

有了公鑰和密鑰，就能進行加密和解密了。

（1）加密要用公鑰 (n,e)

假設鮑勃要向愛麗絲發送加密信息m，他就要用愛麗絲的公鑰 (n,e) 對m進行加密。這里需要注意，m必須是整數（字元串可以取ascii值或unicode值），且m必須小於n。

所謂"加密"，就是算出下式的c：

me ≡ c (mod n)

愛麗絲的公鑰是 (3233, 17)，鮑勃的m假設是65，那麼可以算出下面的等式：

6517 ≡ 2790 (mod 3233)

於是，c等於2790，鮑勃就把2790發給了愛麗絲。

（2）解密要用私鑰(n,d)

愛麗絲拿到鮑勃發來的2790以後，就用自己的私鑰(3233, 2753) 進行解密。可以證明，下面的等式一定成立：

cd ≡ m (mod n)

也就是說，c的d次方除以n的余數為m。現在，c等於2790，私鑰是(3233, 2753)，那麼，愛麗絲算出

27902753 ≡ 65 (mod 3233)

因此，愛麗絲知道了鮑勃加密前的原文就是65。

至此，"加密--解密"的整個過程全部完成

原文1: http://www.ruanyifeng.com/blog/2013/06/rsa_algorithm_part_one.html

原文2: http://www.ruanyifeng.com/blog/2013/07/rsa_algorithm_part_two.html

❽ RSA密碼體制抗破解的原理是什麼

RSA密碼體制抗破解的原理是：利用Euclid 演算法計算解密密鑰d, 滿足de≡1(mod φ(n))。其中n和d也要互質。數e和n是公鑰，d是私鑰。兩個素數p和q不再需要，應該丟棄，不要讓任何人知道。

現在常規的密碼破解方式有兩種，分別是暴力破解和字典破解。通常的破解軟體你還可以設置字元集（比如選擇是否算上符號，大小寫字母和數字等）。用這種方式只要密碼不超過能破譯的長度范圍，在一定時間下是一定能破解出來的，唯一缺點就是速度太慢。

為提高保密強度

RSA密鑰至少為500位長，一般推薦使用1024位。這就使加密的計算量很大。為減少計算量，在傳送信息時，常採用傳統加密方法與公開密鑰加密方法相結合的方式，即信息採用改進的DES或IDEA對話密鑰加密，然後使用RSA密鑰加密對話密鑰和信息摘要。對方收到信息後，用不同的密鑰解密並可核對信息摘要。

❾ RSA加密演算法最多支持多少位，最少多少位，較合理的又是多少位，求解

最少幾位都可以，最多幾位都可以，根據安全性，現在通用的是512以上，1024位和2048位比較安全。少了比較容易破解掉，多了計算非常慢