Specifications Version 2.1
目录
1介绍3
2标记法3
3密钥类型4
3.1RSA公钥4
3.2RSA私钥5
4数据转换原语6
4.1I2OSP6
4.2OS2IP7
5密码原语7
5.1加密解密原语7
5.1.1RSAEP7
5.1.2RSADP7
5.2签名和验证原语8
6方案概要8
7加密方案8
7.1RSAES-OAEP8
7.2RSAES-PKCS1-v1_58
8签名方案-附8
8.1RSASSA-PSS8
8.2RSASSA-PKCS1-v1_58
9签名的编码方式-附9
9.1EMSA-PSS9
9.2EMSA-PKCS1-v1_59
10Openssl9
10.1DER9
10.2PEM9
10.2.1例子:PEM格式内容9
10.3rsa_public_key.pem10
10.3.1PEM文件解析11
附录 A ASN.1语法19
A.1 RSA 密钥描述19
A.1.1 RSA 公钥语法19
A.1.2 RSA 私钥语法19
A.2 体系验证20
1介绍
文档提供了基于RSA算法的公钥密码体系的实现提议,包括以下几个方面:
*加密原语
*加密方案
*签名方案-附
*
在RSA wiki(https://en.wikipedia.org/wiki/RSA)上看到有如下描述:
RSA (cryptosystem), the Rivest-Shamir-Adleman cryptosystem, a cryptosystem for public-key encryption
从以上描述中可以看出RSA是一种公钥加密的密码系统。RSA也叫Rivest-Shamir-Adleman cryptosystem,由Ron Rivest, Adi Shamir和Leonard Adleman于MIT提出。RSA名称也是由Ron Rivest, Adi Shamir和Leonard Adleman三人名字中的首字母而来。
2标记法
3密钥类型
本文档中定义的原语和方案中使用了两种密钥类型:RSA公钥和RSA私钥。同时,RSA公钥和RSA私钥组成一个RSA密钥对。
该规范支持所谓的“多素数”("multi-prime")RSA,模数(modulus)可能有两个以上的素因子(prime factor)。
3.1RSA公钥
RSA公钥由两个组件组成:
n RSA模数,一个正整数
e RSA公开(public)指数,一个正整数
一个有效的RSA公钥,RSA模数n为u个不同的奇素数(r_i,i = 1, 2, ..., u,u>=2, 如r_1, r_2, r_3, r_4, r_5,…,r_u。)的乘积。RSA公开(public)指数e是一个3到n-1之间的正整数,满足:
GCD(e,\lambda(n)) = 1
其中\lambda(n)=LCM(r_1 - 1, ..., r_u - 1),例如一组奇素数r_1, r_2, r_3, r_4, r_5,r_6, r_7为2、3、5、7、11、13、17,那么\lambda(n)为1,2,4,6,10,12,16的公倍数。
按照惯例,开始的两个素数r_1和r_2也可能分别由p和q指定。
素数又称质数(prime number),有无限个。一个大于1的自然数,除了1和它自身外,不能被其他自然数整除的数叫做质数;否则称为合数
质数定义为在大于1的自然数中,除了1和它本身以外不再有其他因数的数称为质数。
如2、3、5、7、11、13、17都是些素数
GCD(greatest common divisor),最大公约数。
LCM(least common multiple),最小公倍数。
3.2RSA私钥
一个RSA私钥可能有两种表示。
第一种表示由(n, d)对组成
n RSA模数,一个正整数
d RSA私有指数,一个正整数
第二种表示由一个5元组(p, q, dP, dQ, qInv)和一序列(可能为空)3元组(r_i, d_i, t_i)
组成。i = 3, ..., u,其中的每一个素数不会在5元组中出现。
p 首因子,一个正整数
q 次因子,一个正整数
dP 首因子的CRT指数,一个正整数
dQ 次因子的CRT指数,一个正整数
qInv CRT系数(第一个),一个正整数
r_i 因子(第i个),一个正整数
d_i 因子(第i个)的CRT指数,一个正整数
t_i 因子(第i个)的CRT系数,一个正整数
对于第一种表示,一个有效的RSA私钥,RSA中的模数n和对应RSA公钥中的模数是相同的,并且模数n为u个不同的奇素数(r_i,i = 1, 2, ..., u,u>=2, 如r_1, r_2, r_3, r_4, r_5,…,r_u。)的乘积。RSA私有指数d是一个小于n的正整数,满足:
e * d == 1 (mod \lambda(n))
其中e是RSA公钥中的公开(public)指数,\lambda(n)的定义也和RSA公钥中定义的一样。
对于第二种表示,一个有效的RSA私钥,p和q这两个因子就是RSA模数n的开始两个素数因子(例如,r_1和r_2),CRT指数dP和dQ是一个分别小于p和q的正整数,满足:
e * dP == 1 (mod (p-1))
e * dQ == 1 (mod (q-1))
CRT系数qInv是一个小于p的正整数,满足:
q * qInv == 1 (mod p)
如果u>2, 这种表示将包含一个或多个3元组(r_i, d_i, t_i),i=3, ..., u。因子r_i就是RSA模数n额外的素数因子。每一个CRT指数d_i (i = 3, ..., u)满足:
e * d_i == 1 (mod (r_i - 1))
每一个CRT系数t_i (i = 3, ..., u)是一个小于r_i的正整数,满足:
R_i * t_i == 1 (mod r_i)
其中R_i = r_1 * r_2 * ... * r_(i-1)
4数据转换原语
文档中定义的体系使用了两种数据转换原语。
I2OSP:Integer-to-Octet-String原语
OS2IP: Octet-String-to-Integer原语
4.1I2OSP
I2OSP转换非负整数为一个指定长度的8位位组字符串(octet string)。
I2OSP (x, xLen)
输入:
x 将被转换的非负整数
xLen 返回的8位位组字符串(octet string)的长度。
输出:
X 对应的8位位组字符串(octet string),长度为xLen
错误: “传入的非负整数太大”
4.2OS2IP
5密码原语
5.1加密解密原语
加密原语输入一个表示明文的整数,在指定公钥下加密输出一个表示密文的整数,解密原语是加密原语的逆过程,输入表示密文的整数,在指定对应的私钥下输出恢复原来的表示明文的整数。
文档中定义加密体系使用了一对加密解密原语:
RSAEP/RSADP
RSAEP和RSADP围绕相同的数学操作,只是输入的密钥不同,RSAEP输入的是公钥,RSADP输入的是私钥。
这里定义的原语和IEEE标准 1363-2000 [26]中IFEP-RSA/IFDP-RSA是一致的(除非新增了RSA多素数的支持),同时兼容PKCS #1 v1.5
这两个原语主要的数学操作就是求幂。
5.1.1RSAEP
RSAEP(RSA Encryption primitives), RSA加密原语
RSAEP((n, e), m)
输入:
(n, e) RSA公钥
m 信息描述,一个整数(0到n-1)
输出:
c 密文描述,一个整数(0到n-1)
错误:“信息描述超过了范围”
假定:RSA公钥(n, e)有效
步骤:
1、如果信息描述m不在0到n-1之间,输出“信息描述超过了范围”并退出。
2、对c作如下运算:c = m^e mod n
3、输出c。
5.1.2RSADP
RSADP(RSA Decryption primitives), RSA解密原语
RSADP (K, c)
输入:
K RSA私钥,其中K可以是以下形式中的一个:
- (n, d)对
-一个5元组(p, q, dP, dQ, qInv)和一序列(可能为空)3元组(r_i, d_i, t_i), i = 3, ..., u
c 一个表示密文的整数,该整数在0到n-1之间。
输出:
m 一个表示明文的整数,该整数在0到n-1之间。
错误:“表示密文的整数超过了范围”
假定:RSA私钥K有效
步骤:
1、如果表示密文的整数c不在0到n-1之间,输出“表示密文的整数超过了范围”并退出。
2、对表示明文的整数m作如下运算:
a.如果K使用的是第一种形式:(n, d)对,对m作如下运算:m = c^d mod n
b.如果K使用的是第二种形式:一个5元组(p, q, dP, dQ, qInv)和一序列(可能为空)3元组(r_i, d_i, t_i), i = 3, ..., u,处理如下:
i.赋值m_1 = c^dP mod p,以及m_2 = c^dQ mod q
ii.如果u>2,赋值m_i = c^(d_i) mod r_i, i = 3, ..., u
iii.赋值h = (m_1 - m_2) * qInv mod p
iv.赋值m = m_2 + q * h
v.如果u>2,赋值R = r_1,并且遍历i=3到u,执行:
1.赋值R = R * r_(i-1)
2.赋值h = (m_i - m) * t_i mod r_i
3.赋值m = m + R * h
3、输出m
5.2签名和验证原语
6方案概要
7加密方案
7.1RSAES-OAEP
7.2RSAES-PKCS1-v1_5
8签名方案-附
8.1RSASSA-PSS
8.2RSASSA-PKCS1-v1_5
9签名的编码方式-附
9.1EMSA-PSS
9.2EMSA-PKCS1-v1_5
10Openssl
10.1DER
二进制DER编码
10.2PEM
PEM stands for Privacy Enhanced Mail. PEM文件采用的是ASCII(Base64)编码,PEM文件使用Base64进行编码。
10.2.1例子:PEM格式内容
-----BEGIN PRIVACY-ENHANCED MESSAGE-----
Proc-Type: 4,ENCRYPTED
Content-Domain: RFC822
DEK-Info: DES-CBC,F8143EDE5960C597
Originator-ID-Symmetric: linn@zendia.enet.dec.com,,
Recipient-ID-Symmetric: linn@zendia.enet.dec.com,ptf-kmc,3
Key-Info: DES-ECB,RSA-MD2,9FD3AAD2F2691B9A,
B70665BB9BF7CBCDA60195DB94F727D3
Recipient-ID-Symmetric: pem-dev@tis.com,ptf-kmc,4
Key-Info: DES-ECB,RSA-MD2,161A3F75DC82EF26,
E2EF532C65CBCFF79F83A2658132DB47
LLrHB0eJzyhP+/fSStdW8okeEnv47jxe7SJ/iN72ohNcUk2jHEUSoH1nvNSIWL9M
8tEjmF/zxB+bATMtPjCUWbz8Lr9wloXIkjHUlBLpvXR0UrUzYbkNpk0agV2IzUpk
J6UiRRGcDSvzrsoK+oNvqu6z7Xs5Xfz5rDqUcMlK1Z6720dcBWGGsDLpTpSCnpot
dXd/H5LMDWnonNvPCwQUHt==
-----END PRIVACY-ENHANCED MESSAGE-----
genrsa -out rsa_key.pem 1024
rsa -in rsa_key.pem -noout -text
genrsa -des -out rsa_key_endes.pem 1024
genrsa -des3 -out rsa_key_endes3.pem 1024
genrsa -aes128 -out rsa_key_enaes128.pem 1024
pkcs8 -topk8 -inform PEM -in rsa_key.pem -outform PEM -nocrypt -out key.pem
rsa -in rsa_key.pem -pubout -out rsa_public_key.pem
10.3rsa_public_key.pem
假设生成的RSA公钥(rsa_public_key.pem文件)内容如下:
-----BEGIN PUBLIC KEY-----
MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDW/XkRFZ+FtYB3bfHYnRoLyRIm
ch4+6ymFh3K8O9Cbb0HZg64MLi3lnyW3zoqMWjUI5aszCoZ2duqNy/BSBFtmuBGn
OK6i6QWmPZu+c8NpfVbWe5GxWXg/yeaYv5GlpA2hBlnDw3UDUdl6pyZyUH+PAN5i
yQwAq7JjDh8p9V4G9QIDAQAB
-----END PUBLIC KEY-----
10.3.1PEM文件解析
typedef void bio_info_cb(struct bio_st *, int, const char *, int, long, long);
struct crypto_ex_data_st
{
STACK_OF(void) *sk;
int dummy; /* gcc is screwing up this data structure :-( */
};
typedef struct crypto_ex_data_st CRYPTO_EX_DATA;
struct bio_st
{
BIO_METHOD *method;
/* bio, mode, argp, argi, argl, ret */
long (*callback)(struct bio_st *,int,const char *,int, long,long);
char *cb_arg; /* first argument for the callback */
int init;
int shutdown;
int flags;/* extra storage */
int retry_reason;
int num;
void *ptr;
struct bio_st *next_bio;/* used by filter BIOs */
struct bio_st *prev_bio;/* used by filter BIOs */
int references;
unsigned long num_read;
unsigned long num_write;
CRYPTO_EX_DATA ex_data;
};
typedef struct bio_st BIO;
typedef struct bio_method_st
{
int type;
const char *name;
int (*bwrite)(BIO *, const char *, int);
int (*bread)(BIO *, char *, int);
int (*bputs)(BIO *, const char *);
int (*bgets)(BIO *, char *, int);
long (*ctrl)(BIO *, int, long, void *);
int (*create)(BIO *);
int (*destroy)(BIO *);
long (*callback_ctrl)(BIO *, int, bio_info_cb *);
} BIO_METHOD;
static int MS_CALLBACK file_gets(BIO *bp, char *buf, int size)
{
int ret=0;
buf[0]='\0';
if (bp->flags&BIO_FLAGS_UPLINK)
{
if (!UP_fgets(buf,size,bp->ptr))
goto err;
}
else
{
if (!fgets(buf,size,(FILE *)bp->ptr))
goto err;
}
if (buf[0] != '\0')
ret=strlen(buf);
err:
return(ret);
}
static BIO_METHOD methods_filep=
{
BIO_TYPE_FILE,
"FILE pointer",
file_write,
file_read,
file_puts,
file_gets,
file_ctrl,
file_new,
file_free,
NULL,
};
BIO_METHOD *BIO_s_file(void)
{
return(&methods_filep);
}
BIO *BIO_new(BIO_METHOD *method)
{
BIO *ret=NULL;
ret=(BIO *)OPENSSL_malloc(sizeof(BIO));
if (ret == NULL)
{
BIOerr(BIO_F_BIO_NEW,ERR_R_MALLOC_FAILURE);
return(NULL);
}
if (!BIO_set(ret,method))
{
OPENSSL_free(ret);
ret=NULL;
}
return(ret);
}
long BIO_ctrl(BIO *b, int cmd, long larg, void *parg)
{
long ret;
long (*cb)(BIO *,int,const char *,int,long,long);
if (b == NULL) return(0);
if ((b->method == NULL) || (b->method->ctrl == NULL))
{
BIOerr(BIO_F_BIO_CTRL,BIO_R_UNSUPPORTED_METHOD);
return(-2);
}
cb=b->callback;
if ((cb != NULL) &&
((ret=cb(b,BIO_CB_CTRL,parg,cmd,larg,1L)) <= 0))
return(ret);
ret=b->method->ctrl(b,cmd,larg,parg);
if (cb != NULL)
ret=cb(b,BIO_CB_CTRL|BIO_CB_RETURN,parg,cmd,
larg,ret);
return(ret);
}
#define BIO_set_fp(b,fp,c)BIO_ctrl(b,BIO_C_SET_FILE_PTR,c,(char *)fp)
int BIO_gets(BIO *b, char *in, int inl)
{
int i;
long (*cb)(BIO *,int,const char *,int,long,long);
if ((b == NULL) || (b->method == NULL) || (b->method->bgets == NULL))
{
BIOerr(BIO_F_BIO_GETS,BIO_R_UNSUPPORTED_METHOD);
return(-2);
}
cb=b->callback;
if ((cb != NULL) &&
((i=(int)cb(b,BIO_CB_GETS,in,inl,0L,1L)) <= 0))
return(i);
if (!b->init)
{
BIOerr(BIO_F_BIO_GETS,BIO_R_UNINITIALIZED);
return(-2);
}
i=b->method->bgets(b,in,inl);
if (cb != NULL)
i=(int)cb(b,BIO_CB_GETS|BIO_CB_RETURN,in,inl,
0L,(long)i);
return(i);
}
int PEM_read_bio(BIO *bp, char **name, char **header, unsigned char **data,
long *len)
{
EVP_ENCODE_CTX ctx;
int end=0,i,k,bl=0,hl=0,nohead=0;
char buf[256];
BUF_MEM *nameB;
BUF_MEM *headerB;
BUF_MEM *dataB,*tmpB;
nameB=BUF_MEM_new();
headerB=BUF_MEM_new();
dataB=BUF_MEM_new();
if ((nameB == NULL) || (headerB == NULL) || (dataB == NULL))
{
BUF_MEM_free(nameB);
BUF_MEM_free(headerB);
BUF_MEM_free(dataB);
PEMerr(PEM_F_PEM_READ_BIO,ERR_R_MALLOC_FAILURE);
return(0);
}
buf[254]='\0';
for (;;)
{
i=BIO_gets(bp,buf,254);
if (i <= 0)
{
PEMerr(PEM_F_PEM_READ_BIO,PEM_R_NO_START_LINE);
goto err;
}
while ((i >= 0) && (buf[i] <= ' ')) i--;
buf[++i]='\n'; buf[++i]='\0';
if (strncmp(buf,"-----BEGIN ",11) == 0)
{
i=strlen(&(buf[11]));
if (strncmp(&(buf[11+i-6]),"-----\n",6) != 0)
continue;
if (!BUF_MEM_grow(nameB,i+9))
{
PEMerr(PEM_F_PEM_READ_BIO,ERR_R_MALLOC_FAILURE);
goto err;
}
memcpy(nameB->data,&(buf[11]),i-6);
nameB->data[i-6]='\0';
break;
}
}
hl=0;
if (!BUF_MEM_grow(headerB,256))
{ PEMerr(PEM_F_PEM_READ_BIO,ERR_R_MALLOC_FAILURE); goto err; }
headerB->data[0]='\0';
for (;;)
{
i=BIO_gets(bp,buf,254);
if (i <= 0) break;
while ((i >= 0) && (buf[i] <= ' ')) i--;
buf[++i]='\n'; buf[++i]='\0';
if (buf[0] == '\n') break;
if (!BUF_MEM_grow(headerB,hl+i+9))
{ PEMerr(PEM_F_PEM_READ_BIO,ERR_R_MALLOC_FAILURE); goto err; }
if (strncmp(buf,"-----END ",9) == 0)
{
nohead=1;
break;
}
memcpy(&(headerB->data[hl]),buf,i);
headerB->data[hl+i]='\0';
hl+=i;
}
bl=0;
if (!BUF_MEM_grow(dataB,1024))
{ PEMerr(PEM_F_PEM_READ_BIO,ERR_R_MALLOC_FAILURE); goto err; }
dataB->data[0]='\0';
if (!nohead)
{
for (;;)
{
i=BIO_gets(bp,buf,254);
if (i <= 0) break;
while ((i >= 0) && (buf[i] <= ' ')) i--;
buf[++i]='\n'; buf[++i]='\0';
if (i != 65) end=1;
if (strncmp(buf,"-----END ",9) == 0)
break;
if (i > 65) break;
if (!BUF_MEM_grow_clean(dataB,i+bl+9))
{
PEMerr(PEM_F_PEM_READ_BIO,ERR_R_MALLOC_FAILURE);
goto err;
}
memcpy(&(dataB->data[bl]),buf,i);
dataB->data[bl+i]='\0';
bl+=i;
if (end)
{
buf[0]='\0';
i=BIO_gets(bp,buf,254);
if (i <= 0) break;
while ((i >= 0) && (buf[i] <= ' ')) i--;
buf[++i]='\n'; buf[++i]='\0';
break;
}
}
}
else
{
tmpB=headerB;
headerB=dataB;
dataB=tmpB;
bl=hl;
}
i=strlen(nameB->data);
if ((strncmp(buf,"-----END ",9) != 0) ||
(strncmp(nameB->data,&(buf[9]),i) != 0) ||
(strncmp(&(buf[9+i]),"-----\n",6) != 0))
{
PEMerr(PEM_F_PEM_READ_BIO,PEM_R_BAD_END_LINE);
goto err;
}
EVP_DecodeInit(&ctx);
i=EVP_DecodeUpdate(&ctx,
(unsigned char *)dataB->data,&bl,
(unsigned char *)dataB->data,bl);
if (i < 0)
{
PEMerr(PEM_F_PEM_READ_BIO,PEM_R_BAD_BASE64_DECODE);
goto err;
}
i=EVP_DecodeFinal(&ctx,(unsigned char *)&(dataB->data[bl]),&k);
if (i < 0)
{
PEMerr(PEM_F_PEM_READ_BIO,PEM_R_BAD_BASE64_DECODE);
goto err;
}
bl+=k;
if (bl == 0) goto err;
*name=nameB->data;
*header=headerB->data;
*data=(unsigned char *)dataB->data;
*len=bl;
OPENSSL_free(nameB);
OPENSSL_free(headerB);
OPENSSL_free(dataB);
return(1);
err:
BUF_MEM_free(nameB);
BUF_MEM_free(headerB);
BUF_MEM_free(dataB);
return(0);
}
int PEM_read(FILE *fp, char **name, char **header, unsigned char **data,
long *len)
{
BIO *b;
int ret;
if ((b=BIO_new(BIO_s_file())) == NULL)
{
PEMerr(PEM_F_PEM_READ,ERR_R_BUF_LIB);
return(0);
}
BIO_set_fp(b,fp,BIO_NOCLOSE);
ret=PEM_read_bio(b, name, header, data,len);
BIO_free(b);
return(ret);
}
附录 A ASN.1语法
A.1 RSA 密钥描述
A.1.1 RSA 公钥语法
RSAPublicKey ::= SEQUENCE {
modulus INTEGER, -- n
publicExponent INTEGER -- e
}
A.1.2 RSA 私钥语法
RSAPrivateKey ::= SEQUENCE {
version Version,
modulus INTEGER, -- n
publicExponent INTEGER, -- e
privateExponent INTEGER, -- d
prime1 INTEGER, -- p
prime2 INTEGER, -- q
exponent1 INTEGER, -- d mod (p-1)
exponent2 INTEGER, -- d mod (q-1)
coefficient INTEGER, -- (inverse of q) mod p
otherPrimeInfos OtherPrimeInfos OPTIONAL
}
A.2 体系验证
Java RSA加密解密实例
private static RSAPrivateKey privateKey = null; private static byte[] privateKeyEncoded = null; private static RSAPublicKey publicKey = null; private static byte[] publicKeyEncoded = null; @BeforeClass public static void init() /* throws NoSuchAlgorithmException */ { KeyPairGenerator keyPairGenerator = null; try { keyPairGenerator = KeyPairGenerator.getInstance("RSA"); } catch (NoSuchAlgorithmException e) { Assert.fail("no such algorithm: " + e.getMessage()); } keyPairGenerator.initialize(512); KeyPair keyPair = keyPairGenerator.generateKeyPair(); privateKey = (RSAPrivateKey) keyPair.getPrivate(); publicKey = (RSAPublicKey) keyPair.getPublic(); privateKeyEncoded = ((Key) privateKey).getEncoded(); publicKeyEncoded = ((Key) publicKey).getEncoded(); System.out.println("private key: " + Base64.byteArrayToBase64(privateKeyEncoded)); System.out.println("public key: " + Base64.byteArrayToBase64(publicKeyEncoded)); }
加密解密
@org.junit.Test public void test() { String message = "13120983870"; System.out.println(message); PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(privateKeyEncoded); KeyFactory keyFactory = null; try { keyFactory = KeyFactory.getInstance("RSA"); } catch (NoSuchAlgorithmException e) { Assert.fail("no such algorithm: " + e.getMessage()); } PrivateKey privateKey = null; try { privateKey = keyFactory.generatePrivate(pkcs8KeySpec); } catch (InvalidKeySpecException e) { Assert.fail("invalid key spec: " + e.getMessage()); } System.out.println("private key: " + Base64.byteArrayToBase64(((Key) privateKey).getEncoded())); Cipher cipher = null; try { cipher = Cipher.getInstance(keyFactory.getAlgorithm()); } catch (NoSuchAlgorithmException e) { Assert.fail("no such algorithm: " + e.getMessage()); } catch (NoSuchPaddingException e) { Assert.fail("no such padding: " + e.getMessage()); } try { cipher.init(Cipher.ENCRYPT_MODE, privateKey); } catch (InvalidKeyException e) { Assert.fail("invalid key: " + e.getMessage()); } byte[] encryption = null; try { encryption = cipher.doFinal(message.getBytes()); } catch (IllegalBlockSizeException e) { Assert.fail("illegal block size: " + e.getMessage()); } catch (BadPaddingException e) { Assert.fail("bad padding: " + e.getMessage()); } System.out.println("encryption: " + Base64.byteArrayToBase64(encryption)); X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(publicKeyEncoded); try { keyFactory = KeyFactory.getInstance("RSA"); } catch (NoSuchAlgorithmException e) { Assert.fail("no such algorithm: " + e.getMessage()); } PublicKey publicKey = null; try { publicKey = keyFactory.generatePublic(x509KeySpec); } catch (InvalidKeySpecException e) { Assert.fail("invalid key spec: " + e.getMessage()); } System.out.println("public key: " + Base64.byteArrayToBase64(((Key) publicKey).getEncoded())); try { cipher = Cipher.getInstance(keyFactory.getAlgorithm()); } catch (NoSuchAlgorithmException e) { Assert.fail("no such algorithm: " + e.getMessage()); } catch (NoSuchPaddingException e) { Assert.fail("no such padding: " + e.getMessage()); } try { cipher.init(Cipher.DECRYPT_MODE, publicKey); } catch (InvalidKeyException e) { Assert.fail("invalid key: " + e.getMessage()); } byte[] decryption = null; try { decryption = cipher.doFinal(encryption); } catch (IllegalBlockSizeException e) { Assert.fail("illegal block size: " + e.getMessage()); } catch (BadPaddingException e) { Assert.fail("bad padding: " + e.getMessage()); } System.out.println("decryption: " + new String(decryption) + ", base64:" + Base64.byteArrayToBase64(decryption)); }
/** * 使用私钥加密,再使用公钥解密 */ @org.junit.Test public void test1() { String message = "13120983870"; System.out.println(message); // 加密 Cipher cipher = null; try { cipher = Cipher.getInstance("RSA"); } catch (NoSuchAlgorithmException e) { Assert.fail("no such algorithm: " + e.getMessage()); } catch (NoSuchPaddingException e) { Assert.fail("no such padding: " + e.getMessage()); } try { cipher.init(Cipher.ENCRYPT_MODE, privateKey); } catch (InvalidKeyException e) { Assert.fail("invalid key: " + e.getMessage()); } byte[] encryption = null; try { encryption = cipher.doFinal(message.getBytes()); } catch (IllegalBlockSizeException e) { Assert.fail("illegal block size: " + e.getMessage()); } catch (BadPaddingException e) { Assert.fail("bad padding: " + e.getMessage()); } System.out.println("encryption: " + Base64.byteArrayToBase64(encryption)); // 解密 try { cipher = Cipher.getInstance("RSA"); } catch (NoSuchAlgorithmException e) { Assert.fail("no such algorithm: " + e.getMessage()); } catch (NoSuchPaddingException e) { Assert.fail("no such padding: " + e.getMessage()); } try { cipher.init(Cipher.DECRYPT_MODE, publicKey); } catch (InvalidKeyException e) { Assert.fail("invalid key: " + e.getMessage()); } byte[] decryption = null; try { decryption = cipher.doFinal(encryption); } catch (IllegalBlockSizeException e) { Assert.fail("illegal block size: " + e.getMessage()); } catch (BadPaddingException e) { Assert.fail("bad padding: " + e.getMessage()); } System.out.println("decryption: " + new String(decryption) + ", base64:" + Base64.byteArrayToBase64(decryption)); }
private key: MIIBUwIBADANBgkqhkiG9w0BAQEFAASCAT0wggE5AgEAAkEAhLKv2wOrV2BGqXxRyrLSJ6jzMey1kxuthXFO+EBjiI7GuTxYpr6lXxyrfnwuhBz0OrXS4QatE9PT2JudFWMsSQIDAQABAkBSNtM1goR50jB1eYzDZR9Haymh2OJ2jkNn1dfzfxEr3UTjlhv42v7FfmLWl0TISEuW5AxZyZBFHhWP7YNF3RYBAiEAxRixL6dmIpRxndVxcCvml16Cn3J+NDkRyWmzwS0WyXECIQCsWwu6+P88wUEOFTgQ/Z5EQFkCXm5h6dL/EmhUordkWQIgTCvuzmvznQmhn04OOTu+MmHkOZsWCzjDFwQy5EV4uQECIEwTN79EbmxjpJJRvViKiVP4zxDjm3cuXQpnFpPc6nOpAiAEiLzfZvzCI4Vx3KxGrOLxaTWC9KbpCG3IRsLBMN/EqA== public key: MFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBAISyr9sDq1dgRql8Ucqy0ieo8zHstZMbrYVxTvhAY4iOxrk8WKa+pV8cq358LoQc9Dq10uEGrRPT09ibnRVjLEkCAwEAAQ== 13120983870 encryption: ZVT1Gt5cP/KHmogMcWU0TxLm1hYqRXzqsvLCvQr9pDgjVA+yzXM6IWZSdXf2dm+j9XeGS72bHayOIo7Py+tEbQ== decryption: 13120983870, base64:MTMxMjA5ODM4NzA=
Java RSA数字签名实例
/** * private key: MIIBVAIBADANBgkqhkiG9w0BAQEFAASCAT4wggE6AgEAAkEApTHMs+zR16SE0v3npoVbMGo70xX5tJ7HF23SvM2rARkJNtRs4xZRQpWQ1JBZnGna9HcVQsrRAORqYhhTrZ9rMQIDAQABAkAFNrlYrasZErJGQEEiIWP9lwHCvZchLTB4j+TahIV+2iLTiLa21QOqQFmpBqw/uqmHsJGtqtHIXdtgCrGtoLVhAiEA4zpbZ52vkCskvZ2eJ34n6dTsiybZLIMYIdp21kd6mpECIQC6HJ2f0R6BwL/ORYhF6tA1YeXZEKyAuTgDkwgmGN/WoQIgPsXrZHeafbB9iOiXPX/LlPyekF6eFn7s1sVcmRvMEhECIBnJDS2vU4K2qdxyVccaGW7L+YRxgvTytIgKPv7IQ3sBAiEAh3XrxyuR3nJhFD5pPcRLmnst9Ag6WQuthc/SgkKJlXk= * public key: MFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBAKUxzLPs0dekhNL956aFWzBqO9MV+bSexxdt0rzNqwEZCTbUbOMWUUKVkNSQWZxp2vR3FULK0QDkamIYU62fazECAwEAAQ== */ @Test public void signAndVerityWithEncoded0() { String privateKey = "MIIBVAIBADANBgkqhkiG9w0BAQEFAASCAT4wggE6AgEAAkEApTHMs+zR16SE0v3npoVbMGo70xX5tJ7HF23SvM2rARkJNtRs4xZRQpWQ1JBZnGna9HcVQsrRAORqYhhTrZ9rMQIDAQABAkAFNrlYrasZErJGQEEiIWP9lwHCvZchLTB4j+TahIV+2iLTiLa21QOqQFmpBqw/uqmHsJGtqtHIXdtgCrGtoLVhAiEA4zpbZ52vkCskvZ2eJ34n6dTsiybZLIMYIdp21kd6mpECIQC6HJ2f0R6BwL/ORYhF6tA1YeXZEKyAuTgDkwgmGN/WoQIgPsXrZHeafbB9iOiXPX/LlPyekF6eFn7s1sVcmRvMEhECIBnJDS2vU4K2qdxyVccaGW7L+YRxgvTytIgKPv7IQ3sBAiEAh3XrxyuR3nJhFD5pPcRLmnst9Ag6WQuthc/SgkKJlXk="; String publicKey = "MFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBAKUxzLPs0dekhNL956aFWzBqO9MV+bSexxdt0rzNqwEZCTbUbOMWUUKVkNSQWZxp2vR3FULK0QDkamIYU62fazECAwEAAQ=="; byte[] privateKeyEncoded = Base64.base64ToByteArray(privateKey); byte[] publicKeyEncoded = Base64.base64ToByteArray(publicKey); String message = "13120983870"; System.out.println(message); signAndVerity(message, privateKeyEncoded, publicKeyEncoded); }
private void signAndVerity(String message, byte[] privateKeyEncoded, byte[] publicKeyEncoded) { // 签名 PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(privateKeyEncoded); KeyFactory keyFactory = null; try { keyFactory = KeyFactory.getInstance("RSA"); } catch (NoSuchAlgorithmException e) { Assert.fail("no such algorithm: " + e.getMessage()); } PrivateKey privateKey = null; try { privateKey = keyFactory.generatePrivate(pkcs8KeySpec); } catch (InvalidKeySpecException e) { Assert.fail("invalid key spec: " + e.getMessage()); } System.out.println("private key: " + Base64.byteArrayToBase64(((Key) privateKey).getEncoded())); Signature signature = null; try { signature = Signature.getInstance("MD5withRSA"); } catch (NoSuchAlgorithmException e) { Assert.fail("no such algorithm: " + e.getMessage()); } try { signature.initSign(privateKey); } catch (InvalidKeyException e) { Assert.fail("invalid key: " + e.getMessage()); } byte[] sign = null; try { signature.update(message.getBytes()); sign = signature.sign(); } catch (SignatureException e) { Assert.fail("signature: " + e.getMessage()); } System.out.println("signature: " + Base64.byteArrayToBase64(sign)); // 验证 X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(publicKeyEncoded); try { keyFactory = KeyFactory.getInstance("RSA"); } catch (NoSuchAlgorithmException e) { Assert.fail("no such algorithm: " + e.getMessage()); } PublicKey publicKey = null; try { publicKey = keyFactory.generatePublic(x509KeySpec); } catch (InvalidKeySpecException e) { Assert.fail("invalid key spec: " + e.getMessage()); } System.out.println("public key: " + Base64.byteArrayToBase64(((Key) publicKey).getEncoded())); try { signature.initVerify(publicKey); } catch (InvalidKeyException e) { Assert.fail("invalid key: " + e.getMessage()); } byte[] decryption = null; try { signature.update(message.getBytes()); boolean result = signature.verify(sign); Assert.assertTrue(result); } catch (SignatureException e) { Assert.fail("signature: " + e.getMessage()); } }
private key: MIIBUwIBADANBgkqhkiG9w0BAQEFAASCAT0wggE5AgEAAkEA36Luv7yDI5RCnvC/d8HFvqXHa5Iry2bBX1qDo2KQkzlMzr5mVnMCk3WOA49PVyQ9EPJa7kIrfRlSdp38R3FB1wIDAQABAkA5nUxM8VAHtoaDVBq/y5gaSbNar0nBGTPwUO1hBl+gzcMGgPEw4F1DaYelt+dUxbD7po4OPiiHz/F5+HJAV5SBAiEA72yOz+HfhCqkvQ5l4dSIpoSmfcw05CxnMBe2p+FtskcCIQDvHpAGQ8po0l0NIgyK+bUIuuHDOUb5ePWtiA4kSrGr8QIgWfgONlnndy/bFdv6NwF5lDFWqwD4gyGYaP8QOUfBw/MCIBQJx5/+xlOKbWnQVKTA0D7vCkRF5IC7djsYj7bS25jBAiAS/IX4KRsV9TayXXDeuqaD8Z+ONQ/98xJwAabcNAmXrA== public key: MFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBAN+i7r+8gyOUQp7wv3fBxb6lx2uSK8tmwV9ag6NikJM5TM6+ZlZzApN1jgOPT1ckPRDyWu5CK30ZUnad/EdxQdcCAwEAAQ== 13120983870 private key: MIIBVAIBADANBgkqhkiG9w0BAQEFAASCAT4wggE6AgEAAkEApTHMs+zR16SE0v3npoVbMGo70xX5tJ7HF23SvM2rARkJNtRs4xZRQpWQ1JBZnGna9HcVQsrRAORqYhhTrZ9rMQIDAQABAkAFNrlYrasZErJGQEEiIWP9lwHCvZchLTB4j+TahIV+2iLTiLa21QOqQFmpBqw/uqmHsJGtqtHIXdtgCrGtoLVhAiEA4zpbZ52vkCskvZ2eJ34n6dTsiybZLIMYIdp21kd6mpECIQC6HJ2f0R6BwL/ORYhF6tA1YeXZEKyAuTgDkwgmGN/WoQIgPsXrZHeafbB9iOiXPX/LlPyekF6eFn7s1sVcmRvMEhECIBnJDS2vU4K2qdxyVccaGW7L+YRxgvTytIgKPv7IQ3sBAiEAh3XrxyuR3nJhFD5pPcRLmnst9Ag6WQuthc/SgkKJlXk= signature: YVuyrhVPkQhydhWWe9+TMAPnDCRVpy3mM0Q2tDQsWhJTOntYlH7t7/ENj76flzOmXr6zSfNZX6Qnh2SbRQkm+Q== public key: MFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBAKUxzLPs0dekhNL956aFWzBqO9MV+bSexxdt0rzNqwEZCTbUbOMWUUKVkNSQWZxp2vR3FULK0QDkamIYU62fazECAwEAAQ==
1、PKCS #1: RSA Encryption Version 1.5,https://www.rfc-editor.org/rfc/rfc2313.txt
2、PKCS #1: RSA Cryptography Specifications Version 2.0,https://www.ietf.org/rfc/rfc2437.txt
3、Public-Key Cryptography Standards (PKCS) #1: RSA Cryptography Specifications Version 2.1,https://www.rfc-editor.org/rfc/rfc3447.txt
4、https://people.cs.umass.edu/~emery/classes/cmpsci691st/scribe/lecture14-rsa.pdf
5、https://en.wikipedia.org/wiki/RSA_(cryptosystem)
6、https://en.wikipedia.org/wiki/RSA
7、PEM, Privacy Enhancement for Internet Electronic Mail: Part I: Message Encipherment and Authentication Procedures, https://www.rfc-editor.org/rfc/rfc1040.txt
8、PEM, Privacy Enhancement for Internet Electronic Mail: Part I -- Message Encipherment and Authentication Procedures, https://www.rfc-editor.org/rfc/rfc1113.txt
9、PEM,Privacy Enhancement for Internet Electronic Mail: Part I: Message Encryption and Authentication Procedures,https://www.rfc-editor.org/rfc/rfc1421.txt
10、PEM, Privacy Enhancement for Internet Electronic Mail: Part II: Certificate-Based Key Management, https://www.rfc-editor.org/rfc/rfc1422.txt
11、PEM, Privacy Enhancement for Internet Electronic Mail: Part III: Algorithms, Modes, and Identifiers, https://www.rfc-editor.org/rfc/rfc1423.txt
12、PEM, Privacy Enhancement for Internet Electronic Mail: Part IV: Key Certification and Related Services, https://www.rfc-editor.org/rfc/rfc1424.txt
相关推荐
PKCS #1(Public-Key Cryptography Standards #1)是RSA安全公司制定的一系列公开密钥加密标准之一,其中“PKCS #1: RSA Cryptography Specifications Version 2.2”是关于RSA算法实施的重要规范,详细定义了基于RSA...
总之,《PKCS #1: RSA Cryptography Specifications Version 2.1》是一份详尽的技术文档,不仅为实现基于RSA算法的公钥密码系统提供了全面的指导,还深入介绍了RSA算法本身及其各种应用场景。这对于理解和应用RSA...
RFC3447,又称为“Public-Key Cryptography Standards (PKCS) #1: RSA Cryptography Specifications Version 2.1”,是由互联网工程任务组(IETF)发布的一份规范,详细定义了RSA算法的操作和安全建议。该文档涵盖了...
RFC文档是互联网相关的技术规范和协议,关于RSA,可能参考的是RFC 3447(Public-Key Cryptography Standards (PKCS) #1: RSA Cryptography Specifications Version 2.1)。遵循RFC标准能确保实现的兼容性和安全性。...
RSA加密标准,全称为Public-Key Cryptography Standards(公钥密码标准)的第1号标准版本2.2,由RSA实验室于2012年10月27日发布。这一标准规范了基于RSA算法的公钥加密技术的应用,内容广泛,涵盖了密码学原语、加密...
### Java安全算法RSA...- [RFC 3447 - PKCS #1: RSA Cryptography Specifications Version 2.1](https://tools.ietf.org/html/rfc3447) - [Bouncy Castle Cryptography APIs](http://www.bouncycastle.org/java.html)
在RSA加密手册(2.1)中,详细介绍了RSA加密的各种技术细节和实施标准。根据手册内容,以下是相关的知识点: 1. RSA公钥和私钥:RSA算法中包含两种密钥,分别是公钥和私钥。公钥可以公开,用于加密数据;私钥必须...
PKCS(Public Key Cryptography Standards)是由RSA安全公司制定的一系列密码学标准,其中PKCS#1是关于RSA密钥管理和操作的标准。在PKCS#1 v2.1中,RSAEP_OAEP是对RSA加密操作的一种增强方式,它引入了OAEP(Optimal...
PKCS #5是RSA实验室发布的公钥密码标准(PKCS)系列的一部分,其文档编号为PKCS#5 v2.0,该版本由B. Kaliski起草,当前为草稿状态,有效期至2000年11月。该文档为密码学领域提供了基于密码的加密规范建议,旨在为...
PKCS #1 v2.1 是 RSA 加密标准的一个版本,由 RSA 实验室发布,旨在为基于 RSA 算法的公钥密码学提供实施建议。该标准涵盖了以下几个核心方面: 1. **加密原语**:PKCS #1 提供了 RSA 加密的基本操作,包括加密...
在PKCS#1 v2.1标准中,详细规定了RSA加密和签名的机制,包括RSA加密过程(RSAEP)、RSA解密过程(RSADP)、以及用于数字签名的RSA签名过程(RSASP1)和验证过程(RSAVP1)。其中,RSAES-OAEP(Optimal Asymmetric ...
PKCS #1 v2.1: RSA Cryptography Standard PKCS #1 v2.0: RSA Cryptography Standard PKCS #1 v2.0 Amendment 1: Multi-Prime RSA PKCS #1: RSA Encryption Standard PKCS #3: Diffie-Hellman Key-Agreement ...
PKCS(Public-Key Cryptography Standards)是由RSA安全公司制定的一系列标准,其中PKCS#1是关于RSA算法的标准,详细定义了RSA算法的使用方式和数据格式。 在PKCS#1 v2.1版本中,主要涵盖了RSA算法的实现细节,包括...
RSA算法是一种非对称加密算法,它在信息安全领域扮演着至关重要的角色,特别是在网络通信、数据加密和数字签名等方面。该算法由Ron Rivest、Adi Shamir和Leonard Adleman于1977年提出,因此得名RSA。在C语言中实现...
《PKCS#1 v2.1 RSA算法标准》是中国版的RSA算法标准文档,PKCS(Public Key Cryptography Standards)是由RSA安全公司制定的一系列公开密钥加密标准,其中PKCS#1主要涉及RSA公钥加密算法。该标准详细规定了RSA加密、...
PKCS__1_v2.1_RSA_算法标准.pdf 中文版 这篇文档是介绍基于 RSA 算法[42]的公钥密码系统的实现方法的,它包括以下几个方面: z 密码原语 z 加密方案 z 带附属的签名方案 z 密钥和方案的 ASN.1 描述
采用Visual C++ 6.0开发的一个RSA加解密工具。支持文件加密、文件解密、文本加密、文本解密。 此版本相对于1.0版本加入了本地化的功能,支持英文、简体中文和繁体中文三种语言方案,可以动态在配置文件里面根据需要...
采用Visual C++ 6.0开发的一个RSA加解密工具。支持文件加密、文件解密、文本加密、文本解密。 文件包括源代码和安装包,源代码里包括自定义的RSA加密解密模型,方便复用。 程序采用分层的设计方案,将底层的RSA加密...
RSA算法,全称为Rivest-Shamir-Adleman,是公钥密码学领域中最著名的一种非对称加密算法,由Ron Rivest、Adi Shamir和Leonard Adleman在1977年提出。它在互联网安全、数字签名、数据加密等方面有着广泛的应用。RSA的...