升级1.2版本: 公钥也区分PKCS#1和PKCS#8

Author: xiangyuecn

Program.cs

@@ -11,11 +11,11 @@ static void RSATest() {
 			Console.WriteLine("【" + rsa.KeySize + "私钥（XML）】：");
 			Console.WriteLine(rsa.ToXML());
 			Console.WriteLine();
-			Console.WriteLine("【" + rsa.KeySize + "私钥（PEM）】：");
-			Console.WriteLine(rsa.ToPEM_PKCS1());
+			Console.WriteLine("【" + rsa.KeySize + "私钥（PKCS#1）】：");
+			Console.WriteLine(rsa.ToPEM().ToPEM_PKCS1());
 			Console.WriteLine();
-			Console.WriteLine("【" + rsa.KeySize + "公钥（PEM）】：");
-			Console.WriteLine(rsa.ToPEM_PKCS1(true));
+			Console.WriteLine("【" + rsa.KeySize + "公钥（PKCS#8）】：");
+			Console.WriteLine(rsa.ToPEM().ToPEM_PKCS8(true));
 			Console.WriteLine();
 
 			var str = "abc内容123";
@@ -30,33 +30,44 @@ static void RSATest() {
 			Console.WriteLine(rsa.Sign("SHA1", str));
 			Console.WriteLine();
 
-			var rsa2 = new RSA(rsa.ToPEM_PKCS8(), true);
+			var rsa2 = new RSA(rsa.ToPEM().ToPEM_PKCS8(), true);
 			Console.WriteLine("【用PEM新创建的RSA是否和上面的一致】：");
 			Console.WriteLine("XML：" + (rsa2.ToXML() == rsa.ToXML()));
-			Console.WriteLine("PKCS1：" + (rsa2.ToPEM_PKCS1() == rsa.ToPEM_PKCS1()));
-			Console.WriteLine("PKCS8：" + (rsa2.ToPEM_PKCS8() == rsa.ToPEM_PKCS8()));
+			Console.WriteLine("PKCS1：" + (rsa2.ToPEM().ToPEM_PKCS1() == rsa.ToPEM().ToPEM_PKCS1()));
+			Console.WriteLine("PKCS8：" + (rsa2.ToPEM().ToPEM_PKCS8() == rsa.ToPEM().ToPEM_PKCS8()));
 
 			var rsa3 = new RSA(rsa.ToXML());
 			Console.WriteLine("【用XML新创建的RSA是否和上面的一致】：");
 			Console.WriteLine("XML：" + (rsa3.ToXML() == rsa.ToXML()));
-			Console.WriteLine("PKCS1：" + (rsa3.ToPEM_PKCS1() == rsa.ToPEM_PKCS1()));
-			Console.WriteLine("PKCS8：" + (rsa3.ToPEM_PKCS8() == rsa.ToPEM_PKCS8()));
+			Console.WriteLine("PKCS1：" + (rsa3.ToPEM().ToPEM_PKCS1() == rsa.ToPEM().ToPEM_PKCS1()));
+			Console.WriteLine("PKCS8：" + (rsa3.ToPEM().ToPEM_PKCS8() == rsa.ToPEM().ToPEM_PKCS8()));
 
 			//--------RSA_PEM验证---------
 			RSA_PEM pem = rsa.ToPEM();
 			Console.WriteLine("【RSA_PEM是否和原始RSA一致】：");
 			Console.WriteLine(pem.KeySize + "位");
 			Console.WriteLine("XML：" + (pem.ToXML(false) == rsa.ToXML()));
-			Console.WriteLine("PKCS1：" + (pem.ToPEM(false, false) == rsa.ToPEM_PKCS1()));
-			Console.WriteLine("PKCS8：" + (pem.ToPEM(false, true) == rsa.ToPEM_PKCS8()));
+			Console.WriteLine("PKCS1：" + (pem.ToPEM_PKCS1() == rsa.ToPEM().ToPEM_PKCS1()));
+			Console.WriteLine("PKCS8：" + (pem.ToPEM_PKCS8() == rsa.ToPEM().ToPEM_PKCS8()));
 			Console.WriteLine("仅公钥：");
 			Console.WriteLine("XML：" + (pem.ToXML(true) == rsa.ToXML(true)));
-			Console.WriteLine("PKCS1：" + (pem.ToPEM(true, false) == rsa.ToPEM_PKCS1(true)));
-			Console.WriteLine("PKCS8：" + (pem.ToPEM(true, true) == rsa.ToPEM_PKCS8(true)));
+			Console.WriteLine("PKCS1：" + (pem.ToPEM_PKCS1(true) == rsa.ToPEM().ToPEM_PKCS1(true)));
+			Console.WriteLine("PKCS8：" + (pem.ToPEM_PKCS8(true) == rsa.ToPEM().ToPEM_PKCS8(true)));
 
 			var rsa4 = new RSA(new RSA_PEM(pem.Key_Modulus, pem.Key_Exponent, pem.Key_D));
 			Console.WriteLine("【用n、e、d构造解密】");
 			Console.WriteLine(rsa4.DecodeOrNull(en));
+
+
+
+
+			Console.WriteLine();
+			Console.WriteLine();
+			Console.WriteLine("【" + rsa.KeySize + "私钥（PKCS#8）】：");
+			Console.WriteLine(rsa.ToPEM().ToPEM_PKCS8());
+			Console.WriteLine();
+			Console.WriteLine("【" + rsa.KeySize + "公钥（PKCS#1）】：不常见的公钥格式");
+			Console.WriteLine(rsa.ToPEM().ToPEM_PKCS1(true));
 		}
 
 

Properties/AssemblyInfo.cs

@@ -29,5 +29,5 @@
 //      生成号
 //      修订号
 //
-[assembly: AssemblyVersion("1.1.0.0")]
-[assembly: AssemblyFileVersion("1.1.0.0")]
+[assembly: AssemblyVersion("1.2.0.0")]
+[assembly: AssemblyFileVersion("1.2.0.0")]

README.md

@@ -37,7 +37,7 @@
 
 项目里面需要引入程序集`System.Numerics`用来支持`BigInteger`，vs默认创建的项目是不会自动引入此程序集的，要手动引入。
 
-注：openssl `RSAPublicKey_out`导出的公钥，字节码内并不带[OID](http://www.oid-info.com/get/1.2.840.113549.1.1.1)（目测是因为不带OID所以openssl自己都不支持用这个公钥来加密数据），RSA_PEM支持此格式公钥的导入，但不提供此种格式公钥的导出。
+注：`openssl rsa -in 私钥文件 -pubout`导出的是PKCS#8格式公钥（用的比较多），`openssl rsa -pubin -in PKCS#8公钥文件 -RSAPublicKey_out`导出的是PKCS#1格式公钥（用的比较少）。
 
 
 ### 构造方法
@@ -64,7 +64,11 @@ bool：**HasPrivate**(是否包含私钥)
 
 **RSACryptoServiceProvider GetRSA()**：将PEM中的公钥私钥转成RSA对象，如果未提供私钥，RSA中就只包含公钥。
 
-**string ToPEM(bool convertToPublic, bool usePKCS8)**：将RSA中的密钥对转换成PEM格式，usePKCS8=false时返回PKCS#1格式，否则返回PKCS#8格式，如果convertToPublic含私钥的RSA将只返回公钥，仅含公钥的RSA不受影响。
+**string ToPEM(bool convertToPublic, bool privateUsePKCS8, bool publicUsePKCS8)**：将RSA中的密钥对转换成PEM格式。convertToPublic：等于true时含私钥的RSA将只返回公钥，仅含公钥的RSA不受影响 。**privateUsePKCS8**：私钥的返回格式，等于true时返回PKCS#8格式（`-----BEGIN PRIVATE KEY-----`），否则返回PKCS#1格式（`-----BEGIN RSA PRIVATE KEY-----`），返回公钥时此参数无效；两种格式使用都比较常见。**publicUsePKCS8**：公钥的返回格式，等于true时返回PKCS#8格式（`-----BEGIN PUBLIC KEY-----`），否则返回PKCS#1格式（`-----BEGIN RSA PUBLIC KEY-----`），返回私钥时此参数无效；一般用的多的是true PKCS#8格式公钥，PKCS#1格式公钥似乎比较少见。
+
+**string ToPEM_PKCS1(bool convertToPublic=false)**：ToPEM方法的简化写法，不管公钥还是私钥都返回PKCS#1格式；似乎导出PKCS#1公钥用的比较少，PKCS#8的公钥用的多些，私钥#1#8都差不多。
+
+**string ToPEM_PKCS8(bool convertToPublic=false)**：ToPEM方法的简化写法，不管公钥还是私钥都返回PKCS#8格式。
 
 **string ToXML(bool convertToPublic)**：将RSA中的密钥对转换成XML格式，如果convertToPublic含私钥的RSA将只返回公钥，仅含公钥的RSA不受影响。
 
@@ -91,6 +95,10 @@ bool：**HasPrivate**(是否包含私钥)
 
 **RSA(RSA_PEM pem)**：通过一个pem对象创建RSA，pem为公钥或私钥，出错抛异常。
 
+**RSA(byte[] modulus, byte[] exponent, byte[] d, byte[] p, byte[] q, byte[] dp, byte[] dq, byte[] inverseQ)**：本方法会先生成RSA_PEM再创建RSA。通过全量的PEM字段数据构造一个PEM，除了模数modulus和公钥指数exponent必须提供外，其他私钥指数信息要么全部提供，要么全部不提供（导出的PEM就只包含公钥）注意：所有参数首字节如果是0，必须先去掉。
+
+**RSA(byte[] modulus, byte[] exponent, byte[] dOrNull)**：本方法会先生成RSA_PEM再创建RSA。通过公钥指数和私钥指数构造一个PEM，会反推计算出P、Q但和原始生成密钥的P、Q极小可能相同。注意：所有参数首字节如果是0，必须先去掉。出错将会抛出异常。私钥指数可以不提供，导出的PEM就只包含公钥。
+
 
 ### 实例属性
 
@@ -105,11 +113,7 @@ bool：**HasPrivate**(是否包含私钥)
 
 **string ToXML(bool convertToPublic = false)**：导出`XML格式`秘钥对。如果RSA包含私钥，默认会导出私钥，设置仅仅导出公钥时只会导出公钥；不包含私钥只会导出公钥。
 
-**string ToPEM_PKCS1(bool convertToPublic = false)**：导出`PEM PKCS#1格式`秘钥对。如果RSA包含私钥，默认会导出私钥，设置仅仅导出公钥时只会导出公钥；不包含私钥只会导出公钥。
-
-**string ToPEM_PKCS8(bool convertToPublic = false)**：导出`PEM PKCS#8格式`秘钥对。如果RSA包含私钥，默认会导出私钥，设置仅仅导出公钥时只会导出公钥；不包含私钥只会导出公钥。
-
-**RSA_PEM ToPEM(bool convertToPublic = false)**：导出RSA_PEM对象，如果convertToPublic含私钥的RSA将只返回公钥，仅含公钥的RSA不受影响。
+**RSA_PEM ToPEM(bool convertToPublic = false)**：导出RSA_PEM对象，如果convertToPublic含私钥的RSA将只返回公钥，仅含公钥的RSA不受影响；通过RSA_PEM.ToPEM方法可以导出PEM文本。
 
 **string Encode(string str)**：加密操作，支持任意长度数据。
 
@@ -189,19 +193,18 @@ PEM格式中，每段数据基本上都是`type+长度数据占用位数+长度
 内容前面要加0（可能现在全部是加0吧，数据结尾这个字节不满8位？什么情况下会出现不够1字节？不够就用二进制0补齐，然后内容前面加补了几位）。
 
 
-### PEM公钥编码格式
-`PKCS#1`、`PKCS#8`公钥编码都是统一的格式。
+### PEM PKCS#8公钥编码格式
 
 ```
-/*****1024位公钥*****/
+/*****1024位PKCS#8公钥*****/
 -----BEGIN PUBLIC KEY-----
 MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCYw9+M3+REzDtYqwBrs/as/Oy8
 GRE5OmnqOV0EfkEiCIjiczbVEFnZ3qRjLbDATfmBxNQ6c6Fga8nX28glEH/aL/RG
 2KdpI8KMUqKAszNydsHSeh9MSKcd5zgS4NuE0u+eR7CB8kOWipiLDQmY38kpM36p
 RWdNQlpIaTDo5IhJJwIDAQAB
 -----END PUBLIC KEY-----
 
-/*****二进制表述*****/
+/*****二进制表述(文本是16进制下同)*****/
 30819F300D06092A864886F70D010101050003818D003081890281810098C3DF8CDFE444CC3B58AB006BB3F6ACFCECBC1911393A69EA395D047E41220888E27336D51059D9DEA4632DB0C04DF981C4D43A73A1606BC9D7DBC825107FDA2FF446D8A76923C28C52A280B3337276C1D27A1F4C48A71DE73812E0DB84D2EF9E47B081F243968A988B0D0998DFC929337EA945674D425A486930E8E48849270203010001
 
 
@@ -221,7 +224,6 @@ RWdNQlpIaTDo5IhJJwIDAQAB
 	, 30_SEQUENCE:{
 		02_INTEGER: "整数"
 		, 02_INTEGER: "整数"
-		, 02_INTEGER: "整数"
 	}
 }
 */
@@ -260,6 +262,33 @@ RWdNQlpIaTDo5IhJJwIDAQAB
 ```
 
 
+### PEM PKCS#1公钥编码格式
+
+```
+/*****1024位PKCS#1公钥*****/
+-----BEGIN RSA PUBLIC KEY-----
+MIGJAoGBAJjD34zf5ETMO1irAGuz9qz87LwZETk6aeo5XQR+QSIIiOJzNtUQWdne
+pGMtsMBN+YHE1DpzoWBrydfbyCUQf9ov9EbYp2kjwoxSooCzM3J2wdJ6H0xIpx3n
+OBLg24TS755HsIHyQ5aKmIsNCZjfySkzfqlFZ01CWkhpMOjkiEknAgMBAAE=
+-----END RSA PUBLIC KEY-----
+
+/*****二进制表述*****/
+3081890281810098C3DF8CDFE444CC3B58AB006BB3F6ACFCECBC1911393A69EA395D047E41220888E27336D51059D9DEA4632DB0C04DF981C4D43A73A1606BC9D7DBC825107FDA2FF446D8A76923C28C52A280B3337276C1D27A1F4C48A71DE73812E0DB84D2EF9E47B081F243968A988B0D0998DFC929337EA945674D425A486930E8E48849270203010001
+
+
+/*****二进制分解（和PKCS#8公钥格式就是只留了N、E两个数据，及其简单）*****/
+30 81 89
+
+	/*RSA Modulus*/
+	02 81 81
+		0098C3DF8CDFE444CC3B58AB006BB3F6ACFCECBC1911393A69EA395D047E41220888E27336D51059D9DEA4632DB0C04DF981C4D43A73A1606BC9D7DBC825107FDA2FF446D8A76923C28C52A280B3337276C1D27A1F4C48A71DE73812E0DB84D2EF9E47B081F243968A988B0D0998DFC929337EA945674D425A486930E8E4884927
+	
+	/*RSA Exponent*/
+	02 03
+		010001
+```
+
+
 ### PEM PKCS#1私钥编码格式
 
 ```
@@ -398,7 +427,7 @@ openssl genrsa -out private.pem 1024
 ::提取公钥PKCS#8
 openssl rsa -in private.pem -pubout -out public.pem
 
-::转换成RSAPublicKey PKCS#1?
+::转换成RSAPublicKey PKCS#1
 openssl rsa -pubin -in public.pem -RSAPublicKey_out -out public.pem.rsakey
 
 ::加密
@@ -407,8 +436,8 @@ echo abcd123 | openssl rsautl -encrypt -inkey public.pem -pubin -out data.enc.bi
 ::解密
 openssl rsautl -decrypt -in data.enc.bin -inkey private.pem -out data.dec.txt
 
-::测试RSAPublicKey PKCS#1?，不出意外会出错
-::因为这个公钥里面没有OID，通过RSA_PEM转换成PKCS#1自动带上OID就能正常加密
+::测试RSAPublicKey PKCS#1，不出意外会出错
+::因为这个公钥里面没有OID，通过RSA_PEM转换成PKCS#8自动带上OID就能正常加密
 echo abcd123 | openssl rsautl -encrypt -inkey public.pem.rsakey -pubin
 ```
 

RSA.cs

@@ -16,18 +16,6 @@ public string ToXML(bool convertToPublic = false) {
 			return rsa.ToXmlString(!rsa.PublicOnly && !convertToPublic);
 		}
 		/// <summary>
-		/// 导出PEM PKCS#1格式密钥对，如果convertToPublic含私钥的RSA将只返回公钥，仅含公钥的RSA不受影响
-		/// </summary>
-		public string ToPEM_PKCS1(bool convertToPublic = false) {
-			return new RSA_PEM(rsa).ToPEM(convertToPublic, false);
-		}
-		/// <summary>
-		/// 导出PEM PKCS#8格式密钥对，如果convertToPublic含私钥的RSA将只返回公钥，仅含公钥的RSA不受影响
-		/// </summary>
-		public string ToPEM_PKCS8(bool convertToPublic = false) {
-			return new RSA_PEM(rsa).ToPEM(convertToPublic, true);
-		}
-		/// <summary>
 		/// 将密钥对导出成PEM对象，如果convertToPublic含私钥的RSA将只返回公钥，仅含公钥的RSA不受影响
 		/// </summary>
 		public RSA_PEM ToPEM(bool convertToPublic = false) {
@@ -213,5 +201,23 @@ public RSA(string pem, bool noop) {
 		public RSA(RSA_PEM pem) {
 			rsa = pem.GetRSA();
 		}
+		/// <summary>
+		/// 本方法会先生成RSA_PEM再创建RSA：通过公钥指数和私钥指数构造一个PEM，会反推计算出P、Q但和原始生成密钥的P、Q极小可能相同
+		/// 注意：所有参数首字节如果是0，必须先去掉
+		/// 出错将会抛出异常
+		/// </summary>
+		/// <param name="modulus">必须提供模数</param>
+		/// <param name="exponent">必须提供公钥指数</param>
+		/// <param name="dOrNull">私钥指数可以不提供，导出的PEM就只包含公钥</param>
+		public RSA(byte[] modulus, byte[] exponent, byte[] dOrNull) {
+			rsa = new RSA_PEM(modulus, exponent, dOrNull).GetRSA();
+		}
+		/// <summary>
+		/// 本方法会先生成RSA_PEM再创建RSA：通过全量的PEM字段数据构造一个PEM，除了模数modulus和公钥指数exponent必须提供外，其他私钥指数信息要么全部提供，要么全部不提供（导出的PEM就只包含公钥）
+		/// 注意：所有参数首字节如果是0，必须先去掉
+		/// </summary>
+		public RSA(byte[] modulus, byte[] exponent, byte[] d, byte[] p, byte[] q, byte[] dp, byte[] dq, byte[] inverseQ) {
+			rsa = new RSA_PEM(modulus, exponent, d, p, q, dp, dq, inverseQ).GetRSA();
+		}
 	}
 }

RSA_PEM.cs

@@ -295,7 +295,7 @@ static public RSA_PEM FromPEM(string pem) {
 				//读取数据总长度
 				readLen(0x30);
 
-				//看看有没有oid
+				//检测PKCS8
 				var idx2 = idx;
 				if (eq(_SeqOID)) {
 					//读取1长度
@@ -363,11 +363,30 @@ static public RSA_PEM FromPEM(string pem) {
 
 
 
-
 		/// <summary>
-		/// 将RSA中的密钥对转换成PEM格式，usePKCS8=false时返回PKCS#1格式，否则返回PKCS#8格式，如果convertToPublic含私钥的RSA将只返回公钥，仅含公钥的RSA不受影响
+		/// 将RSA中的密钥对转换成PEM PKCS#1格式
+		/// 。convertToPublic：等于true时含私钥的RSA将只返回公钥，仅含公钥的RSA不受影响
+		/// 。公钥如：-----BEGIN RSA PUBLIC KEY-----，私钥如：-----BEGIN RSA PRIVATE KEY-----
+		/// 。似乎导出PKCS#1公钥用的比较少，PKCS#8的公钥用的多些，私钥#1#8都差不多
 		/// </summary>
-		public string ToPEM(bool convertToPublic, bool usePKCS8) {
+		public string ToPEM_PKCS1(bool convertToPublic = false) {
+			return ToPEM(convertToPublic, false, false);
+		}
+		/// <summary>
+		/// 将RSA中的密钥对转换成PEM PKCS#8格式
+		/// 。convertToPublic：等于true时含私钥的RSA将只返回公钥，仅含公钥的RSA不受影响
+		/// 。公钥如：-----BEGIN PUBLIC KEY-----，私钥如：-----BEGIN PRIVATE KEY-----
+		/// </summary>
+		public string ToPEM_PKCS8(bool convertToPublic = false) {
+			return ToPEM(convertToPublic, true, true);
+		}
+		/// <summary>
+		/// 将RSA中的密钥对转换成PEM格式
+		/// 。convertToPublic：等于true时含私钥的RSA将只返回公钥，仅含公钥的RSA不受影响
+		/// 。privateUsePKCS8：私钥的返回格式，等于true时返回PKCS#8格式（-----BEGIN PRIVATE KEY-----），否则返回PKCS#1格式（-----BEGIN RSA PRIVATE KEY-----），返回公钥时此参数无效；两种格式使用都比较常见
+		/// 。publicUsePKCS8：公钥的返回格式，等于true时返回PKCS#8格式（-----BEGIN PUBLIC KEY-----），否则返回PKCS#1格式（-----BEGIN RSA PUBLIC KEY-----），返回私钥时此参数无效；一般用的多的是true PKCS#8格式公钥，PKCS#1格式似乎比较少见公钥
+		/// </summary>
+		public string ToPEM(bool convertToPublic, bool privateUsePKCS8, bool publicUsePKCS8) {
 			//https://www.jianshu.com/p/25803dd9527d
 			//https://www.cnblogs.com/ylz8401/p/8443819.html
 			//https://blog.csdn.net/jiayanhui2877/article/details/47187077
@@ -440,18 +459,22 @@ public string ToPEM(bool convertToPublic, bool usePKCS8) {
 				ms.WriteByte(0x30);
 				var index1 = (int)ms.Length;
 
-				//固定内容
-				// encoded OID sequence for PKCS #1 rsaEncryption szOID_RSA_RSA = "1.2.840.113549.1.1.1"
-				writeAll(ms, _SeqOID);
+				//PKCS8 多一段数据
+				int index2 = -1, index3 = -1;
+				if (publicUsePKCS8) {
+					//固定内容
+					// encoded OID sequence for PKCS #1 rsaEncryption szOID_RSA_RSA = "1.2.840.113549.1.1.1"
+					writeAll(ms, _SeqOID);
 
-				//从0x00开始的后续长度
-				ms.WriteByte(0x03);
-				var index2 = (int)ms.Length;
-				ms.WriteByte(0x00);
+					//从0x00开始的后续长度
+					ms.WriteByte(0x03);
+					index2 = (int)ms.Length;
+					ms.WriteByte(0x00);
 
-				//后续内容长度
-				ms.WriteByte(0x30);
-				var index3 = (int)ms.Length;
+					//后续内容长度
+					ms.WriteByte(0x30);
+					index3 = (int)ms.Length;
+				}
 
 				//写入Modulus
 				writeBlock(Key_Modulus);
@@ -463,12 +486,18 @@ public string ToPEM(bool convertToPublic, bool usePKCS8) {
 				//计算空缺的长度
 				var byts = ms.ToArray();
 
-				byts = writeLen(index3, byts);
-				byts = writeLen(index2, byts);
+				if (index2 != -1) {
+					byts = writeLen(index3, byts);
+					byts = writeLen(index2, byts);
+				}
 				byts = writeLen(index1, byts);
 
 
-				return "-----BEGIN PUBLIC KEY-----\n" + TextBreak(Convert.ToBase64String(byts), 64) + "\n-----END PUBLIC KEY-----";
+				var flag = " PUBLIC KEY";
+				if (!publicUsePKCS8) {
+					flag = " RSA" + flag;
+				}
+				return "-----BEGIN" + flag + "-----\n" + TextBreak(Convert.ToBase64String(byts), 64) + "\n-----END" + flag + "-----";
 			} else {
 				/****生成私钥****/
 
@@ -481,7 +510,7 @@ public string ToPEM(bool convertToPublic, bool usePKCS8) {
 
 				//PKCS8 多一段数据
 				int index2 = -1, index3 = -1;
-				if (usePKCS8) {
+				if (privateUsePKCS8) {
 					//固定内容
 					writeAll(ms, _SeqOID);
 
@@ -519,7 +548,7 @@ public string ToPEM(bool convertToPublic, bool usePKCS8) {
 
 
 				var flag = " PRIVATE KEY";
-				if (!usePKCS8) {
+				if (!privateUsePKCS8) {
 					flag = " RSA" + flag;
 				}
 				return "-----BEGIN" + flag + "-----\n" + TextBreak(Convert.ToBase64String(byts), 64) + "\n-----END" + flag + "-----";