本備忘錄的狀態(tài)
本文檔講述了一種Internet社區(qū)的Internet標準跟蹤協(xié)議，它需要進一步進行討論和建
議以得到改進。請參考最新版的“Internet正式協(xié)議標準”(STD1)來獲得本協(xié)議的標準化
程度和狀態(tài)。本備忘錄的發(fā)布不受任何限制。
版權聲明
Copyright(C)TheInternetSociety(2001).

目錄
1.實現(xiàn)概述 2
2.總覽 3
3.術語和符號 3
4.RC5密鑰的描述 4
4.1創(chuàng)建一個RC5密鑰 4
4.2銷毀一個RC5密鑰 5
4.3設置一個RC5密鑰 5
5.設置一個RC5密鑰 6
5.1初始常量定義 7
5.2接口定義 7
5.3轉換密鑰從字節(jié)到字 8
5.4初始化擴展密鑰表 8
5.5混合密鑰 8
６.RC5塊密碼的描述 9
6.1加載A和B的值 9
6.2重申輪函數(shù) 10
6.3存儲A和B的值 10
7．RC5-CBC和RC5-CBC-Pad模式的描述 11
7.1創(chuàng)建密碼對象 11
7.2撤消密碼對象 12
7.3為密碼對象設置初始向量 13
7.5消息的處理部分 14
7.5.1輸出緩沖區(qū)大小的檢查 15
7.5.2將明文分成塊 15
7.6最后塊的處理 16
8.RC5-CTS的描述 17
9.測試程序和向量 18
9.1測試程序和向量 18
9.2測試向量 22
9.3測試結果 23
10.安全考慮 25
11.ASN.1標識符 26
12.參考 26
13.作者地址 27


1.實現(xiàn)概述
這個文檔定義了四種形式的密碼算法擁有足夠的信息以確保不同實現(xiàn)間的協(xié)同工作
能力。第一種是原始的RC5塊加密，RC5密碼使用固定的輸入長度使用一個依靠密鑰的轉
換產(chǎn)生一個固定長度的輸出塊。第二種是，RC5-CBC，是RC5的塊密碼鏈接模式。它能處
理長度是RC5塊尺寸倍數(shù)的消息。第三種是，RC5-CBC-Pad，處理任意長度的明文，盡管
密文將比明文長但長度至多長一個RC5塊。RC5-CTS密碼是RC5算法的密文挪用模式，處
理任意長度的明文且密文的長度匹配明文的長度。
RC5密碼是1994由麻薩諸塞技術研究所的RonaldL.Rivest教授發(fā)明的。它是一種非
常快速且簡單的算法由塊尺寸，輪數(shù)，和密鑰長度參數(shù)化。這些參數(shù)能被調(diào)整以滿足不同的
安全目的，性能和出口能力。
合并的RSA數(shù)據(jù)安全已經(jīng)歸檔了RC5密碼的專利的申請和RC5，RC5-CBC，
RC5-CBC-Pad，RC5-CTS并分類了各種變更。
2.總覽
這個備忘錄是對存在的出版資料的重述。RC5的描述是遵從Rivest教授原始的RC5
論文中的符號和解釋順序。CBC模式出現(xiàn)在參考著作中例如BrUCeSchneier寫的。CBC-Pad
模式與公鑰加密標準（PKCS#5）相同。參考C代碼被包括只是為了清楚等同于英語的描述。
密碼將以一種倒置的面向對象的風格來解釋。首先，RC5密鑰將伴隨著密鑰擴展算
法出現(xiàn)。接著RC5塊密碼將被解釋，最后，將規(guī)定RC5-CBC和RC5-CBC-Pad密碼。為了
簡短，只有加密過程被描述。解密可以通過轉化加密的步驟來實現(xiàn)。
此處的面向對象的描述應該使得實現(xiàn)交互性系統(tǒng)更加輕易，盡管并不像參考文獻中
的功能描述那樣簡單。有兩個對象類，密鑰和密碼算法。兩個類用同一種方式共享創(chuàng)建和撤
消這些對象的操作確保秘密信息沒有被返回給存儲治理者。
密鑰也擁有一個“set”操作拷貝一個秘密密鑰到對象。密碼對象的“set”操作定義
了輪數(shù)，和初始向量。
在這個備忘錄描述了對于密碼對象四個操作。綁定一個密鑰到密碼對象，為每一個
密碼對象設置一個新的初始向量沒有改變密鑰，一個消息的加密部分（對于長的消息要執(zhí)行
多次），和處理消息的最后一個部分可以進行填充或檢查消息的長度。
總之，密碼將根據(jù)這些操作被解釋：

RC5_Key_Create-創(chuàng)建一個密鑰對象.

RC5_Key_Destroy-撤消一個密鑰的對象.

RC5_Key_Set-綁定一個用戶密鑰到密鑰對象.

RC5_CBC_Create-創(chuàng)建一個密碼對象.
RC5_CBC_Destroy-撤消一個密碼對象.

RC5_CBC_Encrypt_Init-綁定一個密鑰對象到一個密碼對象.

RC5_CBC_SetIV-設置一個初始向量不用改變密鑰.

RC5_CBC_Encrypt_Update-一個消息的處理部分.

RC5_CBC_Encrypt_Final-消息末尾的處理.

3.術語和符號
術語“Word”指的是一個非凡長度位數(shù)的字符串既可以作為一個無符號整數(shù)也可以
作為一個位向量。例如一個“word”可以是32位也可以是64位取決于需要的RC5密碼塊的
的尺寸。一個32位字將產(chǎn)生一個64位的塊。為了取得最好的性能RC5子長度應和CPU的寄
存器的長度相匹配。術語“byte”指8位二進制位數(shù)。
下面的變量在此備忘錄中將以如下定義使用：
W這個變量表示的是RC5以二進制位數(shù)計算的字的尺寸。是塊尺寸的一半在此備忘錄
中字的尺寸采用的是32和64。
WW此變量是RC5以字節(jié)計算的字尺寸。
B此變量是以位計算的塊尺寸。是2倍的字尺寸。當RC5被用作64位的塊密碼。B是
64，W是32。0<B<257。在簡單的代碼中，B被用作一個代替密碼系統(tǒng)參數(shù)的變量，
但是這個使用應該是上下文明顯的。
BB此變量是以字節(jié)計算的塊尺寸。BB=B/8。
b這個變量是密鑰的字節(jié)長度。B0<=b<256。
K作為一個b個字節(jié)長的密鑰序列，通過K[0],...,K[b-1]索引。
R此變量是一個內(nèi)部RC5轉換的輪數(shù)。0<=R<256。
T此變量是一個擴展密鑰表的字數(shù)。總是2*(R+1)。1<T<513。
S作為擴展密鑰表的字數(shù)組，通過S[0],..,S[T-1]索引。
N此變量是明文消息的字節(jié)長度。
P作為名文消息以一個N字節(jié)數(shù)組形式存儲，通過P[0],..,P[N-1]索引。
C作為密文輸出以一個字節(jié)數(shù)組形式存儲，通過C[0],C[1],...索引。
I作為CBC模式的初始向量以一個字節(jié)數(shù)組形式存儲，通過I[0],..,I[BB-1]索引。

4.RC5密鑰的描述
像大多數(shù)密碼塊，RC5將一個小的用戶密鑰擴展為一個內(nèi)部密鑰表。用戶密鑰的字節(jié)
長度是密碼的參數(shù)之一。因此RC5的用戶密鑰對象必須能擁有可變長度密鑰。一個C的可能
的結構是：
/*RC5的用戶密鑰對像的定義.*/
typedefstructrc5UserKey
{
intkeyLength;/*InBytes.*/
unsignedchar*keyBytes;
}rc5UserKey;
對密鑰的基本操作是創(chuàng)建，銷毀和設置。為了避免將密鑰資料暴露給一個應用的其他
部分，，密鑰的銷毀操作應該在將分配給密鑰的空間釋放給存儲治理者之前將該存儲空間置
零。一個一般的密鑰對象可以支持其他的操作像產(chǎn)生一個新的隨機密鑰和從協(xié)商的密鑰信息
中獲取密鑰。
4.1創(chuàng)建一個RC5密鑰
創(chuàng)建一個密鑰，密鑰對象的存儲空間必須被分配和初始化。下面的C代碼假設一個
稱作“malloc”的函數(shù)將從堆返回一個未初始化的存儲空間塊，或0指出一個錯誤。
/*分配和初始化一個RC5用戶密鑰.
*假如有問題返回0.
*/
rc5UserKey*RC5_Key_Create()
{
rc5UserKey*pKey;

pKey=(rc5UserKey*)malloc(sizeof(*pKey));
if(pKey!=((rc5UserKey*)0))
{
pKey->keyLength=0;
pKey->keyBytes=(unsignedchar*)0;
}
return(pKey);
}

4.2銷毀一個RC5密鑰
為了銷毀一個密鑰，存儲空間必須被置零和被釋放給一個存儲治理者。以下C代碼
假設稱作“free”的函數(shù)將返回一個存儲塊給堆。
/*置零且釋放一個RC5用戶密鑰.
*/
voidRC5_Key_Destroy(pKey)
rc5UserKey*pKey;
{
unsignedchar*to;
intcount;

if(pKey==((rc5UserKey*)0))
return;
if(pKey->keyBytes==((unsignedchar*)0))
return;
to=pKey->keyBytes;
for(count=0;count<pKey->keyLength;count++)
*to++=(unsignedchar)0;
free(pKey->keyBytes);
pKey->keyBytes=(unsignedchar*)0;
pKey->keyLength=0;
free(pKey);

4.3設置一個RC5密鑰
設置一個密鑰對象將密鑰拷貝到一個從堆分配的存儲空間。
/*設置RC5用戶密鑰的值.
*拷貝密鑰字節(jié)以便調(diào)用者能置零和釋放原來的值.
*假如出現(xiàn)問題返回0
*/
intRC5_Key_Set(pKey,keyLength,keyBytes)
rc5UserKey*pKey;
intkeyLength;
unsignedchar*keyBytes;
{
unsignedchar*keyBytesCopy;
unsignedchar*from,*to;
intcount;

keyBytesCopy=(unsignedchar*)malloc(keyLength);
if(keyBytesCopy==((unsignedchar*)0))
return(0);
from=keyBytes;
to=keyBytesCopy;
for(count=0;count<keyLength;count++)
*to++=*from++;
pKey->keyLength=count;
pKey->keyBytes=keyBytesCopy;
return(1);
}

5.設置一個RC5密鑰
這部分描述了密鑰擴展算法。作為非凡的定義，示例代碼假設塊的大小為64位。幾
個編程參數(shù)依靠于塊大小。
/*定義RC5為一個64位塊密碼.*/
/*The"unsignedint"willbe32bitsonallbut*/
/*theoldestcompilers,whichwillmakeit16bits.*/
/*OnaDECAlpha"unsignedlong"is64bits,not32.*/
#defineRC5_WORDunsignedint
#defineW(32)
#defineWW(W/8)
#defiNeroT_MASK(W-1)
#defineBB((2*W)/8)/*Bytesperblock*／
/*DefinemacrosusedinmultiplePRocedures.*/
/*Thesemacrosassumes">>"isanunsignedOperation,*/
/*andthatxandsareoftypeRC5_WORD.*/
#defineSHL(x,s)((RC5_WORD)((x)<<((s)&ROT_MASK)))
#defineSHR(x,s,w)((RC5_WORD)((x)>>((w)-((s)&ROT_MASK))))
#defineROTL(x,s,w)((RC5_WORD)(SHL((x),(s))SHR((x),(s),(w))))

5.1初始常量定義
兩個常量，Pw和Qw，定義為可以使用任意大小的Ｗ表達式如下：
Pw=Odd((e-2)*2**W)
Qw=Odd((phi-1)*2**W)
ｅ是自然對數(shù)的底（2.71828..．），phi是黃金比例（1.61803．．．），２**W是２的W
此方，Odd（x）等于x假如x是奇數(shù)或等于x+1假如x是偶數(shù)。W等于16，32和64，Pw和
Qw常量是下面的16進制值：
#defineP160xb7e1
#defineQ160x9e37
#defineP320xb7e15163
#defineQ320x9e3779b9
#defineP640xb7e151628aed2a6b
#defineQ640x9e3779b97f4a7c15
#ifW==16
#definePwP16/*Select16bitwordsize*/
#defineQwQ16
#endif
#ifW==32
#definePwP32/*Select32bitwordsize*/
#defineQwQ32
#endif
#ifW==64
#definePwP64/*Select64bitwordsize*/
#defineQwQ64
#endif

5.2接口定義
密鑰擴展規(guī)則轉換b-byte密鑰，K，為一個擴展密鑰，S，是一個T=2*(R+1)個字的
序列。擴展算法使用了兩個常量是來自常量e和phi.這些被用于初始化S,然后使用K進行
修改。使用這個規(guī)則的一個C代碼程序頭如下：
/*EXPandanRC5userkey.
*/
voidRC5_Key_Expand(b,K,R,S)
intb;/*Bytelengthofsecretkey*/
char*K;/*Secretkey*/
intR;/*Numberofrounds*/
RC5_WORD*S;/*Expandedkeybuffer,2*(R+1)words*/
{

5.3轉換密鑰從字節(jié)到字
這個步驟轉換了b-byte密鑰為一個存儲在L數(shù)組中的字序列。在一個小端字節(jié)序的
處理器上通過將L數(shù)組置零再拷貝K的b個字節(jié)實現(xiàn)。下面的代碼將在所有的處理器上獲得
這個效果：
inti,j,k,LL,t,T;
RC5_WORDL[256/WW];/*Basedonmaxkeysize*/
RC5_WORDA,B;

/*LLisnumberofelementsusedinL.*/
LL=(b+WW-1)/WW;
for(i=0;i<LL;i++){
L[i]=0;
}
for(i=0;i<b;i++){
t=(K[i]&0xFF)<<(8*(i%4));/*0,8,16,24*/
L[i/WW]=L[i/WW]+t;
}

5.4初始化擴展密鑰表
這一步使用一個基于Pw加Qw再模２的W次方的算術級的固定偽隨機數(shù)模式來填充
S表。元素S[i]等于i*Qw+Pw模２的W次方。這個表可以被預計算和按所需進行拷貝或在空
閑時間計算。C代碼如下：
T=2*(R+1);
S[0]=Pw;
for(i=1;i<T;i++){
S[i]=S[i-1]+Qw;
}

5.5混合密鑰
這一步混合密鑰Ｋ到擴展密鑰Ｓ。混合函數(shù)的循環(huán)次數(shù)Ｋ為被初始化的Ｌ元素的個
數(shù)的３倍，表示為LL，S中的元素個數(shù)表示為Ｔ。每個循環(huán)類似一個加密內(nèi)部循環(huán)的反復因
為兩個變量A和B是由這個加密循環(huán)的第一部分和第二部分更新的。
A和B的初始值為０，i作為Ｓ數(shù)組的索引，j作為Ｌ數(shù)組的索引。第一個循環(huán)左移
式的局部結果通過計算S[i]，A和B的和得到。然后將這個結果循環(huán)左移３位后賦給A。接
著將A的值賦給S[i]。第二個循環(huán)左移的局部結果通過計算Ｌ[i]，A和B的和得到。然后
將這個結果循環(huán)左移A+B位后賦給B。接著將B的值賦給L[j]。在循環(huán)結束前i、j的值
加１模各自對應的數(shù)組的長度。C代碼如下：
i=j=0;
A=B=0;
if(LL>T)
k=3*LL;/*Secretkeylen>expandedkey.*/
else
k=3*T;/*Secretkeylen<expandedkey.*/
for(;k>0;k--){
A=ROTL(S[i]+A+B,3,W);
S[i]=A;
B=ROTL(L[j]+A+B,A+B,W);
L[j]=B;
i=(i+1)%T;
j=(j+1)%LL;
}
return;
}/*EndofRC5_Key_Expand*/

６.RC5塊密碼的描述
這部分通過解釋對一個簡單輸入塊進行加密操作的步驟來說明RC5塊密碼。解密處理
與加密處理步驟相反，因此在此不對此進行解釋。RC5密碼的參數(shù)有一個版本號,V,一個輪
數(shù),R,一個以位計數(shù)的字尺寸,W。此處的描述對應RC5的原始版本（V=16十六進制數(shù)）囊括
了R的任意正值和W的值16,32和64。
這一處理的輸入是密鑰擴展表，S，輪數(shù)，R，輸入緩沖區(qū)的指針，in，和輸出緩沖區(qū)
的指針，out。一個可能的C代碼程序頭定義如下：
voidRC5_Block_Encrypt(S,R,in,out)
RC5_WORD*S;
intR;
char*in;
char*out;
{

6.1加載A和B的值
這一步轉換輸入字節(jié)為兩個無符號整數(shù)稱作A和B。當RC5被用作64位塊密碼A和B
是32位的值。第一個輸入的字節(jié)作為A的低位字節(jié)。第四個輸入的字節(jié)作為A的高位字字
節(jié)，第五個輸入字節(jié)作為B的低位字節(jié)，最后一個輸入的字節(jié)作為B的高位字節(jié)。這種轉換
對于小端字節(jié)序處理器是非常有效率的例如Intel系列。C代碼表達如下：
inti;
RC5_WORDA,B;

A=in[0]&0xFF;
A+=(in[1]&0xFF)<<8;
A+=(in[2]&0xFF)<<16;
A+=(in[3]&0xFF)<<24;
B=in[4]&0xFF;
B+=(in[5]&0xFF)<<8;
B+=(in[6]&0xFF)<<16;
B+=(in[7]&0xFF)<<24;

6.2重申輪函數(shù)
這一步將擴展密鑰與輸入混合在一起做基本的加密操作。擴展密鑰數(shù)組的頭兩個字]
被分別填充到A和B，然后輪函數(shù)被重復R次。
輪函數(shù)的前半部分基于A、B和擴展密鑰中下一個未用的字的值為A計算一個新的
值。首先A與B異或然后將此結果循環(huán)左移B次。循環(huán)每次循環(huán)W位（例如：對于有64
位塊密碼的RC5版本循環(huán)32位）。實際的循環(huán)次數(shù)至少是B的W位以2為底的對數(shù)。接著
加擴展密鑰數(shù)組的下一個未用的字形成A的新值。
輪函數(shù)的后半部分操作是相同的除了A、B的角色互換一下。非凡B保存A與B異
或的結果然后將此結果循環(huán)左移A次，接著加上下一個擴展密鑰數(shù)組中未用的字成為B的
新值。

用C代碼表達的一種方式如下：
A=A+S[0];
B=B+S[1];
for(i=1;i<=R;i++){
A=A^B;
A=ROTL(A,B,W)+S[2*i];
B=B^A;
B=ROTL(B,A,W)+S[(2*i)+1];
}

6.3存儲A和B的值
最后一步是轉換A和B為一個字節(jié)序列。這是打開操作的反變換。C代碼可能的表
達如下：
out[0]=(A>>0)&0xFF;
out[1]=(A>>8)&0xFF;
out[2]=(A>>16)&0xFF;
out[3]=(A>>24)&0xFF;
out[4]=(B>>0)&0xFF;
out[5]=(B>>8)&0xFF;
out[6]=(B>>16)&0xFF;
out[7]=(B>>24)&0xFF;
return;
}/*EndofRC5_Block_Encrypt*/

7．RC5-CBC和RC5-CBC-Pad模式的描述
這部分描述了RC5密碼的CBC和CBC-Pad模式。這一描述是基于RC5密鑰對象和
較早的RC5塊密碼。

7.1創(chuàng)建密碼對象
密碼對象需要明了填充模式，輪數(shù)，擴展密鑰，初始向量，CBC鏈接塊和輸入緩沖
區(qū)。C代碼可能的結構定義形式如下：
/*DefinitionoftheRC5CBCalgorithmobject.
*/
typedefstructrc5CBCAlg
{
intPad;/*1=RC5-CBC-Pad,0=RC5-CBC.*/
intR;/*Numberofrounds.*/
RC5_WORD*S;/*Expandedkey.*/
unsignedcharI[BB];/*Initializationvector.*/
unsignedcharchainBlock[BB];
unsignedcharinputBlock[BB];
intinputBlockIndex;/*NextinputBlockbyte.*/
}rc5CBCAlg;
創(chuàng)建一個密碼算法對象，參數(shù)必須被檢查然后為擴展密鑰表分配空間。擴展密鑰使用
早先描述的方法來進行初始化。最后，狀態(tài)變量（填充模式、輪數(shù)和輸入緩沖區(qū)）被賦予初
始值。C代碼可能的實現(xiàn)方式如下：
/*AllocateandinitializetheRC5CBCalgorithmobject.
*Return0ifproblems.
*/
rc5CBCAlg*RC5_CBC_Create(Pad,R,Version,bb,I)
intPad;/*1=RC5-CBC-Pad,0=RC5-CBC.*/
intR;/*Numberofrounds.*/
intVersion;/*RC5versionnumber.*/
intbb;/*BytesperRC5block==IVlen.*/
char*I;/*CBCIV,bbbyteslong.*/
{
rc5CBCAlg*pAlg;
intindex;

if((Version!=RC5_FIRST_VERSION)
(bb!=BB)(R<0)(255<R))
return((rc5CBCAlg*)0);
pAlg=(rc5CBCAlg*)malloc(sizeof(*pAlg));
if(pAlg==((rc5CBCAlg*)0))
return((rc5CBCAlg*)0);
pAlg->S=(RC5_WORD*)malloc(BB*(R+1));
if(pAlg->S==((RC5_WORD*)0)){
free(pAlg);
return((rc5CBCAlg*)0);
}
pAlg->Pad=Pad;
pAlg->R=R;
pAlg->inputBlockIndex=0;
for(index=0;index<BB;index++)
pAlg->I[index]=I[index];
return(pAlg);
}

7.2撤消密碼對象
撤消密碼是創(chuàng)建它的反變換所關心的問題是在將存儲空間返回給存儲治理者之前將
其值置為0。C代碼的可能實現(xiàn)方式如下：
/*ZeroandfreeanRC5algorithmobject.
*/
voidRC5_CBC_Destroy(pAlg)
rc5CBCAlg*pAlg;
{
RC5_WORD*to;
intcount;

if(pAlg==((rc5CBCAlg*)0))
return;
if(pAlg->S==((RC5_WORD*)0))
return;
to=pAlg->S;
for(count=0;count<(1+pAlg->R);count++)
{
*to++=0;/*Twoexpandedkeywordsperround.*/
*to++=0;
}
free(pAlg->S);
for(count=0;count<BB;count++)
{
pAlg->I[count]=(unsignedchar)0;
pAlg->inputBlock[count]=(unsignedchar)0;
pAlg->chainBlock[count]=(unsignedchar)0;
}
pAlg->Pad=0;
pAlg->R=0;
pAlg->inputBlockIndex=0;
free(pAlg);
}

7.3為密碼對象設置初始向量
對于CBC密碼對象，算法的狀態(tài)依靠于擴展密鑰，CBC鏈接塊和任何內(nèi)部緩存的
輸入。經(jīng)常相同的密鑰被許多治理者使用每一個擁有獨一無二的初始向量。消除創(chuàng)建新的密
碼對象的系統(tǒng)開銷，提供一個答應調(diào)用者為一個以存在的密碼對象改變初始向量的操作將更
有意義。C代碼的可能實現(xiàn)方式如下：
/*SetupanewinitializationvectorforaCBCoperation
*andresettheCBCobject.
*ThiscanbecalledafterFinalwithoutneedingto
*callInitorCreateagain.
*Returnzeroifproblems.
*/
intRC5_CBC_SetIV(pAlg,I)
rc5CBCAlg*pAlg;
char*I;/*CBCInitializationvector,BBbytes.*/
{
intindex;

pAlg->inputBlockIndex=0;
for(index=0;index<BB;index++)
{
pAlg->I[index]=pAlg->chainBlock[index]=I[index];
pAlg->inputBlock[index]=(unsignedchar)0;
}
return(1);
}

7.4綁定一個密鑰到一個密碼對象
綁定一個密鑰到一個密碼對象的操作執(zhí)行了密鑰擴展。密鑰擴展可能是在密鑰上進
行的一個操作，但是當他們操作時修改擴展密鑰將使之不能為正確的為密碼工作。擴展密鑰
后，這個操作必須用初始向量初始化CBC鏈接塊并且為接受第一個字符預備緩沖區(qū)。C代
碼的操作如下：
/*Initializetheencryptionobjectwiththegivenkey.
*Afterthisroutine,thecallerfreesthekeyobject.
*TheIVforthisCBCobjectcanbechangedbycalling
*theSetIVroutine.Theonlywaytochangethekeyis
*todestroytheCBCobjectandcreateanewone.
*Returnzeroifproblems.
*/
intRC5_CBC_Encrypt_Init(pAlg,pKey)
rc5CBCAlg*pAlg;
rc5UserKey*pKey;
{
if((pAlg==((rc5CBCAlg*)0))
(pKey==((rc5UserKey*)0)))
return(0);
RC5_Key_Expand(Key->keyLength,pKey->keyBytes,
pAlg->R,pAlg->S);
return(RC5_CBC_SetIV(pAlg,pAlg->I));
}

7.5消息的處理部分
此處的加密操作使用Init-Update-Final過程描述。Update操作被用于消息部分的一
個序列為了遞增的產(chǎn)生密文。在最后部分被處理后，F(xiàn)inal被調(diào)用獲得任意的明文字節(jié)或填
充被緩存在密碼對象內(nèi)的明文字節(jié)。這個操作的一個合適的程序頭如下：
/*Encryptabufferofplaintext.
*Theplaintextandciphertextbufferscanbethesame.
*Thebytelenoftheciphertextisputin*pCipherLen.
*Callthismultipletimespassingsuccessive
*partsofalargemessage.
*AfterthelastparthasbeenpassedtoUpdate,
*callFinal.
*Returnzeroifproblemslikeoutputbuffertoosmall.
*/
intRC5_CBC_Encrypt_Update(pAlg,N,P,
pCipherLen,maxCipherLen,C)
rc5CBCAlg*pAlg;/*Cipheralgorithmobject.*/
intN;/*BytelengthofP.*/
char*P;/*Plaintextbuffer.*/
int*pCipherLen;/*GetsbytelenofC.*/
intmaxCipherLen;/*SizeofC.*/
char*C;/*Ciphertextbuffer.*/
{

7.5.1輸出緩沖區(qū)大小的檢查
明文處理的第一步是確保輸出緩沖區(qū)有足夠大的空間存儲密文。密文將以塊大小的
倍數(shù)被產(chǎn)生依靠于被傳遞給這個操作的明文字符的個數(shù)加任意位于密碼對象內(nèi)部緩沖區(qū)的
字符。C代碼如下：
intplainIndex,cipherIndex,j;

/*Checksizeoftheoutputbuffer.*/
if(maxCipherLen<(((pAlg->inputBlockIndex+N)/BB)*BB))
{
*pCipherLen=0;
return(0);
}

7.5.2將明文分成塊
下一步是填充字符到內(nèi)部的緩沖區(qū)直到一個塊被填滿。此時，緩沖區(qū)指針被復位輸
入緩沖區(qū)和CBC鏈接密碼塊相異或。鏈接密碼塊的字節(jié)序和輸入塊相同。例如：第9個輸
入字節(jié)和第一個密文字節(jié)相異或。結果然后被傳遞給先前描述的RC5塊密碼。為了減少數(shù)
據(jù)的移動和字節(jié)調(diào)整的問題，RC5的輸出能被直接的寫到CBC鏈接塊。最后，這個輸出被
拷貝到由用戶提供的密文緩沖區(qū)。在返回前，密文的實際大小被傳遞給調(diào)用者。C代碼如下：
plainIndex=cipherIndex=0;
while(plainIndex<N)
{
if(pAlg->inputBlockIndex<BB)
{
pAlg->inputBlock[pAlg->inputBlockIndex]
=P[plainIndex];
pAlg->inputBlockIndex++;
plainIndex++;
}
if(pAlg->inputBlockIndex==BB)
{/*Haveacompleteinputblock,processit.*/
pAlg->inputBlockIndex=0;
for(j=0;j<BB;j++)
{/*XORinthechainblock.*/
pAlg->inputBlock[j]=pAlg->inputBlock[j]
^pAlg->chainBlock[j];
}
RC5_Block_Encrypt(pAlg->S,pAlg->R
pAlg->inputBlock,
pAlg->chainBlock);
for(j=0;j<BB;j++)
{/*Outputtheciphertext.*/
C[cipherIndex]=pAlg->chainBlock[j];
cipherIndex++;
}
}
}
*pCipherLen=cipherIndex;
return(1);
}/*EndofRC5_CBC_Encrypt_Update*/

7.6最后塊的處理
這一步處理明文的最后一個塊。對于RC5-CBC，這一步只是做錯誤檢查確保明文長
度確實是塊長度的倍數(shù)。對于RC5-CBC-Pad，填充的字節(jié)被添加到明文。填充的字節(jié)都是
相同的其值被置為填充的字節(jié)數(shù)。例如假如填充了8個字節(jié)，填充的字節(jié)其值都為16進制
的0x08。將包含1到BB個填充字節(jié)。C代碼如下：
/*ProducethefinalblocKOFciphertextincludingany
*padding,andthenresetthealgorithmobject.
*Returnzeroifproblems.
*/
intRC5_CBC_Encrypt_Final(pAlg,pCipherLen,maxCipherLen,C)
rc5CBCAlg*pAlg;
int*pCipherLen;/*GetsbytelenofC.*/
intmaxCipherLen;/*LenofCbuffer.*/
char*C;/*Ciphertextbuffer.*/
{
intcipherIndex,j;
intpadLength;

/*Fornon-padmodeerrorifinputbytesbuffered.*/
*pCipherLen=0;
if((pAlg->Pad==0)&&(pAlg->inputBlockIndex!=0))
return(0);

if(pAlg->Pad==0)
return(1);
if(maxCipherLen<BB)
return(0);

padLength=BB-pAlg->inputBlockIndex;
for(j=0;j<padLength;j++)
{
pAlg->inputBlock[pAlg->inputBlockIndex]
=(unsignedchar)padLength;
pAlg->inputBlockIndex++;
}
for(j=0;j<BB;j++)
{/*XORthechainblockintotheplaintextblock.*/
pAlg->inputBlock[j]=pAlg->inputBlock[j]
^pAlg->chainBlock[j];
}
RC5_Block_Encrypt(pAlg->S,pAlg->R,
pAlg->inputBlock,pAlg->chainBlock);
cipherIndex=0;
for(j=0;j<BB;j++)
{/*Outputtheciphertext.*/
C[cipherIndex]=pAlg->chainBlock[j];
cipherIndex++;
}
*pCipherLen=cipherIndex;

/*ResettheCBCalgorithmobject.*/
return(RC5_CBC_SetIV(pAlg,pAlg->I));
}/*EndofRC5_CBC_Encrypt_Final*/

8.RC5-CTS的描述
塊密碼的密碼文本偷竊模式在Schneier的應用密碼學的195和196頁有敘述。這個
模式處理任意長度的明文并且產(chǎn)生于明文長度相匹配的密文。CTS模式除了明文的最后兩個
塊的處理不同外和CBC一致。下面幾步描述了如何處理明文的最后兩個塊，稱作Pn-1和Pn，
Pn-1的長度等于塊大小，BB，最后一個塊Pn長度是Ln字節(jié)。注重Ln從１到BB變化，因
此Pn實際上可以成為一個完整的塊。
１、 異或Pn-1和以前的密文塊，Cn-2，創(chuàng)建Xn-1。
２、 加密Xn-1得En-1。
３、 選擇En-1的前Ln個字節(jié)創(chuàng)建Cn。
４、 在Pn末尾用０填充Pn創(chuàng)建長度為BB的P。
５、 異或En-1和P創(chuàng)建Dn。
６、 加密Dn得Cn-1。
７、 密文的最后兩部分分別為Cn-1和Cn。
實現(xiàn)CTS加密，RC5-CTS對象必須擁有至多2*BB個字節(jié)的明文存儲空間當
RC5_CTS_Encrypt_Final規(guī)則被調(diào)用時單獨處理他們。
下面的步驟描述如何解密Cn-1和Cn。
１、 解密Cn得Dn。
２、 在末尾用０填充Cn創(chuàng)建長度為BB的C。
３、 將Dn和C相異或得Xn。
４、 選擇Xn的前Ln個字節(jié)創(chuàng)建Pn。
５、 將Xn尾部的BB-Ln個字節(jié)添加到Cn得En。
６、 解密En得Pn-1。
７、 明文的最后兩個部分分別是Pn-1和Pn。

9.測試程序和向量
幫助證實實現(xiàn)的正確性，這一部分提供了測試程序和一組測試向量的結果。

9.1測試程序和向量
下面用C寫的測試程序從輸入流中讀測試向量結果寫到輸出流中。下面的子過程給
了一組測試向量用于輸入和結果輸出。
#include<stdio.h>

#defineBLOCK_LENGTH(8/*bytes*/)
#defineMAX_KEY_LENGTH(64/*bytes*/)
#defineMAX_PLAIN_LENGTH(128/*bytes*/)
#defineMAX_CIPHER_LENGTH(MAX_PLAIN_LENGTH+BLOCK_LENGTH)
#defineMAX_ROUNDS(20)
#defineMAX_S_LENGTH(2*(MAX_ROUNDS+1))

typedefstructtest_vector
{
intpadding_mode;
introunds;
charkeytext[2*MAX_KEY_LENGTH+1];
intkey_length;
charkey[MAX_KEY_LENGTH];
charivtext[2*BLOCK_LENGTH+1];
intiv_length;
chariv[BLOCK_LENGTH];
charplaintext[2*MAX_PLAIN_LENGTH+1];
intplain_length;
charplain[MAX_PLAIN_LENGTH];
charciphertext[2*MAX_CIPHER_LENGTH+1];
intcipher_length;
charcipher[MAX_CIPHER_LENGTH];
RC5_WORDS[MAX_S_LENGTH];
}test_vector;

voidshow_banner()
{
(void)printf("RC5CBCTester./n");
(void)printf("Eachinputlineshouldcontainthefollowing/n");
(void)printf("testparametersseparatedbyasinglespace:/n");
(void)printf("-Paddingmodeflag.Use1forRC5_CBC_Pad,else
0./n");
(void)printf("-NumberofroundsforRC5./n");
(void)printf("-Keybytesinhexadecimal.Twocharactersper
bytelike'01'./n");
(void)printf("-IVbytesinhexadecimal.Mustbe16hex
characters./n");
(void)printf("-Plaintextbytesinhexadecimal./n");
(void)printf("Anendoffileorformaterrorterminatesthe
tester./n");
(void)printf("/n");
}
/*Convertabufferfromasciihextobytes.
*SetpTo_lengthtothebytelengthoftheresult.
*Return1ifeverythingwentOK.
*/
inthex_to_bytes(from,to,pTo_length)
char*from,*to;
int*pTo_length;
{
char*pHex;/*Ptrtonexthexcharacter.*/
char*pByte;/*Ptrtonextresultingbyte.*/
intbyte_length=0;
intvalue;

pByte=to;
for(pHex=from;*pHex!=0;pHex+=2){
if(1!=sscanf(pHex,"%02x",&value))
return(0);
*pByte++=((char)(value&0xFF));
byte_length++;
}
*pTo_length=byte_length;
return(1);
}

/*Convertabufferfrombytestoasciihex.
*Return1ifeverythingwentOK.
*/
intbytes_to_hex(from,from_length,to)
char*from,*to;
intfrom_length;
{
char*pHex;/*Ptrtonexthexcharacter.*/
char*pByte;/*Ptrtonextresultingbyte.*/
intvalue;

pHex=to;
for(pByte=from;from_length>0;from_length--){
value=*pByte++&0xFF;
(void)sprintf(pHex,"%02x",value);
pHex+=2;
}
return(1);
}

/*Return1ifgetavalidtestvector.*/
intget_test_vector(ptv)
test_vector*ptv;
{
if(1!=scanf("%d",&ptv->padding_mode))
return(0);
if(1!=scanf("%d",&ptv->rounds))
return(0);
if((ptv->rounds<0)(MAX_ROUNDS<ptv->rounds))
return(0);
if(1!=scanf("%s",&ptv->keytext))
return(0);
if(1!=hex_to_bytes(ptv->keytext,ptv->key,
&ptv->key_length))
return(0);
if(1!=scanf("%s",&ptv->ivtext))
return(0);
if(1!=hex_to_bytes(ptv->ivtext,ptv->iv,
&ptv->iv_length))
return(0);
if(BLOCK_LENGTH!=ptv->iv_length)
return(0);
if(1!=scanf("%s",&ptv->plaintext))
return(0);
if(1!=hex_to_bytes(ptv->plaintext,ptv->plain,
&ptv->plain_length))
return(0);
return(1);
}

voidrun_test(ptv)
test_vector*ptv;
{
rc5UserKey*pKey;
rc5CBCAlg*pAlg;
intnumBytesOut;

pKey=RC5_Key_Create();
RC5_Key_Set(pKey,ptv->key_length,ptv->key);

pAlg=RC5_CBC_Create(ptv->padding_mode,
ptv->rounds,
RC5_FIRST_VERSION,
BB,
ptv->iv);
(void)RC5_CBC_Encrypt_Init(pAlg,pKey);
ptv->cipher_length=0;
(void)RC5_CBC_Encrypt_Update(pAlg,
ptv->plain_length,ptv->plain,
&(numBytesOut),
MAX_CIPHER_LENGTH-ptv->cipher_length,
&(ptv->cipher[ptv->cipher_length]));
ptv->cipher_length+=numBytesOut;
(void)RC5_CBC_Encrypt_Final(pAlg,
&(numBytesOut),
MAX_CIPHER_LENGTH-ptv->cipher_length,
&(ptv->cipher[ptv->cipher_length]));
ptv->cipher_length+=numBytesOut;
bytes_to_hex(ptv->cipher,ptv->cipher_length,
ptv->ciphertext);
RC5_Key_Destroy(pKey);
RC5_CBC_Destroy(pAlg);
}

voidshow_results(ptv)
test_vector*ptv;
{
if(ptv->padding_mode)
printf("RC5_CBC_Pad");
else
printf("RC5_CBC");
printf("R=%2d",ptv->rounds);
printf("Key=%s",ptv->keytext);
printf("IV=%s",ptv->ivtext);
printf("P=%s",ptv->plaintext);
printf("C=%s",ptv->ciphertext);
printf("/n");
}

intmain(argc,argv)
intargc;
char*argv[];
{
test_vectortv;
test_vector*ptv=&tv;

show_banner();
while(get_test_vector(ptv)){
run_test(ptv);
show_results(ptv);
}
return(0);
}

9.2測試向量
下面的文本是前一節(jié)測試程序的輸入文件。輸出在下一節(jié)中給出。

0000000000000000000000000000000000000
000000000000000000000ffffffffffffffff
0000000000000000000010000000000000000
0000000000000000000000000000000000001
0000001020304050607081020304050607080
0011100000000000000000000000000000000
0020000000000000000000000000000000000
0020000000000000000000000000000000000000000
0080000000000000000000000000000000000
0080001020304050607081020304050607080
0120001020304050607081020304050607080
0160001020304050607081020304050607080
008010203040000000000000000ffffffffffffffff
012010203040000000000000000ffffffffffffffff
016010203040000000000000000ffffffffffffffff
01201020304050607080000000000000000ffffffffffffffff
008010203040506070801020304050607081020304050607080
012010203040506070801020304050607081020304050607080
016010203040506070801020304050607081020304050607080
00801020304050607081020304050607080
01020304050607081020304050607080
01201020304050607081020304050607080
01020304050607081020304050607080
01601020304050607081020304050607080
01020304050607081020304050607080

01201020304050000000000000000ffffffffffffffff
00801020304050000000000000000ffffffffffffffff
00801020304057875dbf6738c64780808080808080808
10801020304050000000000000000ffffffffffffffff

008010203040500000000000000000000000000000000
00801020304057cb3f1df34f948111122334455667701

10801020304050000000000000000
ffffffffffffffff7875dbf6738c647811223344556677

9.3測試結果
下面的文本是測試程序運行于前一節(jié)給定輸入的輸出文本。
RC5CBC測試器。
每個輸入行應該包含下面用空格號分隔的測試參數(shù)：
－填充模式標志。使用１表示RC5-CBC-Pad，其余用０表示。
－RC5的輪數(shù)。
－16進制的密鑰。每字節(jié)兩個字符像‘０１’。
－16進制的初始向量。必須是16進制的字節(jié)。
－16進制的明文字節(jié)。
到達文件末尾或格式錯誤終止測試器。

RC5_CBCR=0Key=00IV=0000000000000000
P=0000000000000000C=7a7bba4d79111d1e
RC5_CBCR=0Key=00IV=0000000000000000
P=ffffffffffffffffC=797bba4d78111d1e
RC5_CBCR=0Key=00IV=0000000000000001
P=0000000000000000C=7a7bba4d79111d1f
RC5_CBCR=0Key=00IV=0000000000000000
P=0000000000000001C=7a7bba4d79111d1f
RC5_CBCR=0Key=00IV=0102030405060708
P=1020304050607080C=8b9ded91ce7794a6
RC5_CBCR=1Key=11IV=0000000000000000
P=0000000000000000C=2f759fe7ad86a378
RC5_CBCR=2Key=00IV=0000000000000000
P=0000000000000000C=dca2694bf40e0788
RC5_CBCR=2Key=00000000IV=0000000000000000
P=0000000000000000C=dca2694bf40e0788
RC5_CBCR=8Key=00IV=0000000000000000
P=0000000000000000C=dcfe098577eca5ff
RC5_CBCR=8Key=00IV=0102030405060708
P=1020304050607080C=9646fb77638f9ca8
RC5_CBCR=12Key=00IV=0102030405060708
P=1020304050607080C=b2b3209db6594da4
RC5_CBCR=16Key=00IV=0102030405060708
P=1020304050607080C=545f7f32a5fc3836
RC5_CBCR=8Key=01020304IV=0000000000000000
P=ffffffffffffffffC=8285e7c1b5bc7402
RC5_CBCR=12Key=01020304IV=0000000000000000
P=ffffffffffffffffC=fc586f92f7080934
RC5_CBCR=16Key=01020304IV=0000000000000000
P=ffffffffffffffffC=cf270ef9717ff7c4
RC5_CBCR=12Key=0102030405060708IV=0000000000000000
P=ffffffffffffffffC=e493f1c1bb4d6e8c
RC5_CBCR=8Key=0102030405060708IV=0102030405060708
P=1020304050607080C=5c4c041e0f217ac3
RC5_CBCR=12Key=0102030405060708IV=0102030405060708
P=1020304050607080C=921f12485373b4f7
RC5_CBCR=16Key=0102030405060708IV=0102030405060708
P=1020304050607080C=5ba0ca6bbe7f5fad
RC5_CBCR=8Key=01020304050607081020304050607080
IV=0102030405060708
P=1020304050607080C=c533771cd0110e63
RC5_CBCR=12Key=01020304050607081020304050607080
IV=0102030405060708
P=1020304050607080C=294ddb46b3278d60
RC5_CBCR=16Key=01020304050607081020304050607080
IV=0102030405060708
P=1020304050607080C=dad6bda9dfe8f7e8
RC5_CBCR=12Key=0102030405IV=0000000000000000
P=ffffffffffffffffC=97e0787837ed317f
RC5_CBCR=8Key=0102030405IV=0000000000000000
P=ffffffffffffffffC=7875dbf6738c6478
RC5_CBCR=8Key=0102030405IV=7875dbf6738c6478
P=0808080808080808C=8f34c3c681c99695
RC5_CBC_PadR=8Key=0102030405IV=0000000000000000
P=ffffffffffffffffC=7875dbf6738c64788f34c3c681c99695
RC5_CBCR=8Key=0102030405IV=0000000000000000
P=0000000000000000C=7cb3f1df34f94811
RC5_CBCR=8Key=0102030405IV=7cb3f1df34f94811
P=1122334455667701C=7fd1a023a5bba217
RC5_CBC_PadR=8Key=0102030405IV=0000000000000000
P=ffffffffffffffff7875dbf6738c647811223344556677
C=7875dbf6738c64787cb3f1df34f948117fd1a023a5bba217

10.安全考慮
RC5密碼相對來說是比較新的所以鑒定的評論仍在進行。然而，密碼的簡單結構使
它易于分析而且有希望更輕易的評定它的的強度。迄今為止的評論是有前途的。
早期的結果暗示12輪64位塊大小的RC5將有足夠的能力抗拒線性和差分密碼分
析。128位的塊版本還未像64位的塊版本進行多次研究。但是明顯的16輪是一個合適的最
小值。小于64位的塊尺寸學術上的愛好但是不應被用于密碼安全。更大的安全可以通過增
加輪數(shù)獲得其代價是減少密碼的吞吐量。
密鑰的長度幫助決定密碼對窮舉攻擊的反抗力。一個128位的密鑰長度應該幾十年
的時間里為抗拒資金雄厚的對手的窮舉攻擊提供保護。12輪的RC5，密鑰的建立時間和數(shù)據(jù)
加密時間對于所有長度小于832位的密鑰來說都是相同的。因此沒有因為不需要為了性能要
求而選擇短密鑰。對于大的密鑰，因為用戶的密鑰表，L，將比擴展密鑰表，S，長所以密鑰
擴展的步驟會運行的比較慢。然而，加密時間將不會改變因此它只是一個輪數(shù)的函數(shù)。
未了配合出口規(guī)則可能需要選擇密鑰只有40個未知位。進行這一步處理的簡單方
式是選擇一個簡單的５個字節(jié)的密鑰。這應該被避免因為對手可以輕易的預計算密鑰搜索信
息。另一個一般的機制是選擇128位的密鑰出版頭88位。這個方法揭示了大量的通往用戶
密鑰表，L，的路徑。且是否RC5密鑰擴展表在這種情況下提供了足夠的安全還未進行研究。
盡管它可能是好的。一個與40位密鑰限制一致的一種保守的方法是選擇128位的種子值，
出版這個種子的前88位，通過像md5的散列函數(shù)運行整個種子值，使用這個散列函數(shù)的128
位的輸出作為RC5的密鑰。
在有40位未知密鑰和88位已知密鑰的情況下，對于64位RC5塊版本應該有12
輪或更高的輪數(shù)，否則增加給密鑰的88位的值可能被丟失。
密鑰的生存期也是影響安全的要害。對于高安全的應用，任何64位塊密碼的密鑰
應該在加密了2**32個塊后被改變（2**64個塊對于128位的塊密碼）。這將幫助防范線性
和差分密碼分析。對于64位的塊，這個規(guī)則將推薦在2**40個字節(jié)被加密后改變密鑰。進
一步的討論見Schneier應用密碼學183頁。

11.ASN.1標識符
對于使用ASN.1描述的應用，有必要為這些與他們參數(shù)塊格式相一致的密碼定義算
法標識符。一個算法標識符的ASN.1的定義已經(jīng)存在，以下列出作為參考。
AlgorithmIdentifier::=SEQUENCE{
algorithmOBJECTIDENTIFIER,
parametersANYDEFINEDBYalgorithmOPTIONAL
}

Thevaluesforthealgorithmfieldare:

RC5_CBCOBJECTIDENTIFIER::=
{iso(1)member-body(2)US(840)rsadsi(113549)
encryptionAlgorithm(3)RC5CBC(8)}

RC5_CBC_PadOBJECTIDENTIFIER::=
{iso(1)member-body(2)US(840)rsadsi(113549)
encryptionAlgorithm(3)RC5CBCPAD(9)}

Thestructureoftheparametersfieldforthesealgorithmsisgiven
below.NOTE:iftheivfieldisnotincluded,thenthe
initializationvectordefaultstoablockofzeroswhosesizedepends
ontheblockSizeInBitsfield.

RC5_CBC_Parameters::=SEQUENCE{
versionINTEGER(v1_0(16)),
roundsINTEGER(8..127),
blockSizeInBitsINTEGER(64,128),
ivOCTETSTRINGOPTIONAL
}

12.參考
[1]Kaliski,BurtonS.,andYinqunLisaYin,"OnDifferentialand
LinearCryptanalysisoftheRC5EncryptionAlgorithm",InAdvances
inCryptology-Crypto'95,pages171-184,Springer-Verlag,New
York,1995.

[2]Rivest,RonaldL.,"TheRC5EncryptionAlgorithm",In
ProceedingsoftheSecondInternationalWorkshoponFastSoftware
Encryption,pages86-96,LeuvenBelgium,December1994.

[3]Rivest,RonaldL.,"RC5EncryptionAlgorithm",InDr.Dobbs
Journal,number226,pages146-148,January1995.

[4]Rivest,RonaldL.,"TheMD5Message-DigestAlgorithm",RFC
1321.

[5]RSALaboratories,"PublicKeyCryptographyStandards(PKCS)",
RSADataSecurityInc.SeeFTP.rsa.com.

[6]Schneier,Bruce,"AppliedCryptography",SecondEdition,John
WileyandSons,NewYork,1996.Errata:onpage195,line13,the
referencenumbershouldbe[402].

[7]BusinessSoftwareAlliance,MattBlazeetal.,"MinimumKey
LengthforSymmetricCipherstoProvideAdequateCommercial
Security",http://www.bsa.org/bsa/cryptologists.Html.

[8]RSADataSecurityInc.,"RC5ReferenceCodeinC",Seetheweb
site:www.rsa.com,foravailability.Notavailablewiththefirst
draftofthisdocument.

13.作者地址

RobertW.Baldwin
RSADataSecurity,Inc.
100MarineParkway
RedwoodCity,CA94065

Phone:(415)595-8782
Fax:(415)595-1873
EMail:baldwin@rsa.com,orbaldwin@lcs.mit.edu


RonaldL.Rivest
MassachusettsInstituteofTechnology
LaboratoryforComputerScience
NE43-324
545TechnologySquare
Cambridge,MA02139-1986

Phone:(617)253-5880
EMail:rivest@theory.lcs.mit.edu