/// <summary>
/// rips apart rawKey into public byte [] for RsaParameters class
/// </summary>
public Rsa(byte [] rawKey)
{
this.rawKey = rawKey; //596
pks = new PUBLICKEYSTRUC();
pks.bType = rawKey[0]; //7
pks.bVersion = rawKey[1]; //2
pks.reserved = BitConverter.ToUInt16(rawKey, 2); //0
pks.aiKeyAlg = BitConverter.ToUInt32(rawKey, 4); //41984
kb = (KeyBlob)pks.bType; //PRIVATE
c = (Calg)pks.aiKeyAlg; //RSA_KEYX
if (kb != KeyBlob.PUBLICKEYBLOB && kb != KeyBlob.PRIVATEKEYBLOB)
{
throw new Exception("unsupported blob type");
}
rpk = new RSAPUBKEY();
rpk.magic = BitConverter.ToUInt32(rawKey, 8); //843141970
rpk.bitlen = BitConverter.ToUInt32(rawKey, 12); //1024
rpk.pubexp = BitConverter.ToUInt32(rawKey, 16); //65537
uint byteLen = rpk.bitlen / 8; //128
this.SetSizeAndPosition(rpk.bitlen);
//public
Modulus = Format.GetBytes(this.rawKey, modulusPos, modulusLen, true);
Exponent = Format.GetBytes(this.rawKey, exponentPos, exponentLen, true);
//private
if (kb == KeyBlob.PRIVATEKEYBLOB)
{
this.P = Format.GetBytes(this.rawKey, prime1Pos, prime1Len, true);
this.Q = Format.GetBytes(this.rawKey, prime2Pos, prime2Len, true);
this.DP = Format.GetBytes(this.rawKey, exponent1Pos, exponent1Len, true);
this.DQ = Format.GetBytes(this.rawKey, exponent2Pos, exponent2Len, true);
this.InverseQ = Format.GetBytes(this.rawKey, coefficientPos, coefficientLen, true);
this.D = Format.GetBytes(this.rawKey, privateExponentPos, privateExponentLen, true);
}
else
{
this.P = null;
this.Q = null;
this.DP = null;
this.DQ = null;
this.InverseQ = null;
this.D = null;
}
}
/// <summary>
/// rips apart rawKey into public byte [] for RsaParameters class
/// </summary>
public Rsa(byte [] rawKey)
{
this.rawKey = rawKey; //596
pks = new PUBLICKEYSTRUC();
pks.bType = rawKey[0]; //7
pks.bVersion = rawKey[1]; //2
pks.reserved = BitConverter.ToUInt16(rawKey, 2); //0
pks.aiKeyAlg = BitConverter.ToUInt32(rawKey, 4); //41984
kb = (KeyBlob) pks.bType; //PRIVATE
c = (Calg) pks.aiKeyAlg; //RSA_KEYX
if(kb != KeyBlob.PUBLICKEYBLOB && kb != KeyBlob.PRIVATEKEYBLOB)
throw new Exception("unsupported blob type");
rpk = new RSAPUBKEY();
rpk.magic = BitConverter.ToUInt32(rawKey, 8); //843141970
rpk.bitlen = BitConverter.ToUInt32(rawKey, 12); //1024
rpk.pubexp = BitConverter.ToUInt32(rawKey, 16); //65537
uint byteLen = rpk.bitlen / 8; //128
this.SetSizeAndPosition(rpk.bitlen);
//public
Modulus = Format.GetBytes(this.rawKey, modulusPos, modulusLen, true);
Exponent = Format.GetBytes(this.rawKey, exponentPos, exponentLen, true);
//private
if(kb == KeyBlob.PRIVATEKEYBLOB)
{
this.P = Format.GetBytes(this.rawKey, prime1Pos, prime1Len, true);
this.Q = Format.GetBytes(this.rawKey, prime2Pos, prime2Len, true);
this.DP = Format.GetBytes(this.rawKey, exponent1Pos, exponent1Len, true);
this.DQ = Format.GetBytes(this.rawKey, exponent2Pos, exponent2Len, true);
this.InverseQ = Format.GetBytes(this.rawKey, coefficientPos, coefficientLen, true);
this.D = Format.GetBytes(this.rawKey, privateExponentPos, privateExponentLen, true);
}
else
{
this.P = null;
this.Q = null;
this.DP = null;
this.DQ = null;
this.InverseQ = null;
this.D = null;
}
}
public DiffHell(byte [] rawKey)
{
this.rawKey = rawKey; //400 //144
pks = new PUBLICKEYSTRUC();
pks.bType = rawKey[0]; //7 //6
pks.bVersion = rawKey[1]; //2
pks.reserved = BitConverter.ToUInt16(rawKey, 2); //0
pks.aiKeyAlg = BitConverter.ToUInt32(rawKey, 4); //43522
kb = (KeyBlob)pks.bType; //private //public
c = (Calg)pks.aiKeyAlg; //DH_EPHEM or DH_SF
if (kb != KeyBlob.PUBLICKEYBLOB && kb != KeyBlob.PRIVATEKEYBLOB)
{
throw new Exception("unsupported blob type");
}
dhpk = new DHPUBKEY();
//PRIV 0x32484400. This hex value is the ASCII encoding of "DH2."
//PUB 0x31484400. This hex value is the ASCII encoding of "DH1."
dhpk.magic = BitConverter.ToUInt32(rawKey, 8); //843596800 //826819584
//Number of bits in the prime modulus, P.
dhpk.bitlen = BitConverter.ToUInt32(rawKey, 12); //1024
uint byteLen = dhpk.bitlen / 8; //128
this.SetSizeAndPosition(dhpk.bitlen);
bool revBytes = true;
if (kb == KeyBlob.PRIVATEKEYBLOB)
{
P = Format.GetBytes(this.rawKey, ypPos, ypLen, revBytes);
G = Format.GetBytes(this.rawKey, gPos, gLen, revBytes);
X = Format.GetBytes(this.rawKey, xPos, xLen, revBytes);
}
if (kb == KeyBlob.PUBLICKEYBLOB)
{
Y = Format.GetBytes(this.rawKey, ypPos, ypLen, revBytes);
}
}
public DiffHell(byte [] rawKey)
{
this.rawKey = rawKey; //400 //144
pks = new PUBLICKEYSTRUC();
pks.bType = rawKey[0]; //7 //6
pks.bVersion = rawKey[1]; //2
pks.reserved = BitConverter.ToUInt16(rawKey, 2); //0
pks.aiKeyAlg = BitConverter.ToUInt32(rawKey, 4); //43522
kb = (KeyBlob) pks.bType; //private //public
c = (Calg) pks.aiKeyAlg; //DH_EPHEM or DH_SF
if(kb != KeyBlob.PUBLICKEYBLOB && kb != KeyBlob.PRIVATEKEYBLOB)
throw new Exception("unsupported blob type");
dhpk = new DHPUBKEY();
//PRIV 0x32484400. This hex value is the ASCII encoding of "DH2."
//PUB 0x31484400. This hex value is the ASCII encoding of "DH1."
dhpk.magic = BitConverter.ToUInt32(rawKey, 8); //843596800 //826819584
//Number of bits in the prime modulus, P.
dhpk.bitlen = BitConverter.ToUInt32(rawKey, 12); //1024
uint byteLen = dhpk.bitlen / 8; //128
this.SetSizeAndPosition(dhpk.bitlen);
bool revBytes = true;
if(kb == KeyBlob.PRIVATEKEYBLOB)
{
P = Format.GetBytes(this.rawKey, ypPos, ypLen, revBytes);
G = Format.GetBytes(this.rawKey, gPos, gLen, revBytes);
X = Format.GetBytes(this.rawKey, xPos, xLen, revBytes);
}
if(kb == KeyBlob.PUBLICKEYBLOB)
{
Y = Format.GetBytes(this.rawKey, ypPos, ypLen, revBytes);
}
}
public void BuildRawKey(bool privateKey)
{
//build up rawKey byte[]
uint rsaMagic = 0;
int caSize = 0;
uint bitLen = (uint)this.Modulus.Length * 8;
if (privateKey == true)
{
kb = KeyBlob.PRIVATEKEYBLOB;
caSize = 20 + (9 * ((int)bitLen / 16));
rsaMagic = 0x32415352; //ASCII encoding of "RSA2"
}
else //public
{
kb = KeyBlob.PUBLICKEYBLOB;
caSize = 20 + ((int)bitLen / 8);
rsaMagic = 0x31415352; //ASCII encoding of "RSA1"
}
rawKey = new byte[caSize];
//PUBLICKEYSTRUC
rawKey[0] = (byte)kb; //bType
rawKey[1] = (byte)2; //bVersion
//reserved 2,3
c = Calg.RSA_KEYX;
byte [] baKeyAlg = BitConverter.GetBytes((uint)c); //aiKeyAlg
Buffer.BlockCopy(baKeyAlg, 0, rawKey, 4, 4);
pks = new PUBLICKEYSTRUC();
pks.bType = rawKey[0];
pks.bVersion = rawKey[1];
pks.reserved = BitConverter.ToUInt16(rawKey, 2);
pks.aiKeyAlg = BitConverter.ToUInt32(rawKey, 4);
//RSAPUBKEY
byte [] baMagic = BitConverter.GetBytes(rsaMagic); //magic
Buffer.BlockCopy(baMagic, 0, rawKey, 8, 4);
byte [] baBitlen = BitConverter.GetBytes(bitLen); //bitlen
Buffer.BlockCopy(baBitlen, 0, rawKey, 12, 4);
this.SetSizeAndPosition(bitLen);
Format.SetBytes(this.rawKey, exponentPos, exponentLen, this.Exponent, true); //pubexp
rpk = new RSAPUBKEY();
rpk.magic = BitConverter.ToUInt32(rawKey, 8);
rpk.bitlen = BitConverter.ToUInt32(rawKey, 12);
rpk.pubexp = BitConverter.ToUInt32(rawKey, 16);
uint byteLen = rpk.bitlen / 8;
//public
Format.SetBytes(this.rawKey, modulusPos, modulusLen, this.Modulus, true);
Format.SetBytes(this.rawKey, exponentPos, exponentLen, this.Exponent, true);
//private
if (privateKey == true)
{
Format.SetBytes(this.rawKey, prime1Pos, prime1Len, this.P, true);
Format.SetBytes(this.rawKey, prime2Pos, prime2Len, this.Q, true);
Format.SetBytes(this.rawKey, exponent1Pos, exponent1Len, this.DP, true);
Format.SetBytes(this.rawKey, exponent2Pos, exponent2Len, this.DQ, true);
Format.SetBytes(this.rawKey, coefficientPos, coefficientLen, this.InverseQ, true);
Format.SetBytes(this.rawKey, privateExponentPos, privateExponentLen, this.D, true);
}
else
{
this.P = null;
this.Q = null;
this.DP = null;
this.DQ = null;
this.InverseQ = null;
this.D = null;
}
}
public void BuildRawKey(bool privateKey)
{
//build up rawKey byte[]
uint rsaMagic = 0;
int caSize = 0;
uint bitLen = (uint) this.Modulus.Length * 8;
if(privateKey == true)
{
kb = KeyBlob.PRIVATEKEYBLOB;
caSize = 20 + (9 * ((int)bitLen / 16));
rsaMagic = 0x32415352; //ASCII encoding of "RSA2"
}
else //public
{
kb = KeyBlob.PUBLICKEYBLOB;
caSize = 20 + ((int)bitLen / 8);
rsaMagic = 0x31415352; //ASCII encoding of "RSA1"
}
rawKey = new byte[caSize];
//PUBLICKEYSTRUC
rawKey[0] = (byte) kb; //bType
rawKey[1] = (byte) 2; //bVersion
//reserved 2,3
c = Calg.RSA_KEYX;
byte [] baKeyAlg = BitConverter.GetBytes((uint)c);//aiKeyAlg
Buffer.BlockCopy(baKeyAlg, 0, rawKey, 4, 4);
pks = new PUBLICKEYSTRUC();
pks.bType = rawKey[0];
pks.bVersion = rawKey[1];
pks.reserved = BitConverter.ToUInt16(rawKey, 2);
pks.aiKeyAlg = BitConverter.ToUInt32(rawKey, 4);
//RSAPUBKEY
byte [] baMagic = BitConverter.GetBytes(rsaMagic);//magic
Buffer.BlockCopy(baMagic, 0, rawKey, 8, 4);
byte [] baBitlen = BitConverter.GetBytes(bitLen);//bitlen
Buffer.BlockCopy(baBitlen, 0, rawKey, 12, 4);
this.SetSizeAndPosition(bitLen);
Format.SetBytes(this.rawKey, exponentPos, exponentLen, this.Exponent, true); //pubexp
rpk = new RSAPUBKEY();
rpk.magic = BitConverter.ToUInt32(rawKey, 8);
rpk.bitlen = BitConverter.ToUInt32(rawKey, 12);
rpk.pubexp = BitConverter.ToUInt32(rawKey, 16);
uint byteLen = rpk.bitlen / 8;
//public
Format.SetBytes(this.rawKey, modulusPos, modulusLen, this.Modulus, true);
Format.SetBytes(this.rawKey, exponentPos, exponentLen, this.Exponent, true);
//private
if(privateKey == true)
{
Format.SetBytes(this.rawKey, prime1Pos, prime1Len, this.P, true);
Format.SetBytes(this.rawKey, prime2Pos, prime2Len, this.Q, true);
Format.SetBytes(this.rawKey, exponent1Pos, exponent1Len, this.DP, true);
Format.SetBytes(this.rawKey, exponent2Pos, exponent2Len, this.DQ, true);
Format.SetBytes(this.rawKey, coefficientPos, coefficientLen, this.InverseQ, true);
Format.SetBytes(this.rawKey, privateExponentPos, privateExponentLen, this.D, true);
}
else
{
this.P = null;
this.Q = null;
this.DP = null;
this.DQ = null;
this.InverseQ = null;
this.D = null;
}
}
/// <summary>
/// rips apart rawKey into public byte [] for DsaParameters class
/// </summary>
public Dsa(byte [] rawKey)
{
this.rawKey = rawKey; //336 //444
pks = new PUBLICKEYSTRUC();
pks.bType = rawKey[0]; //7 //6
pks.bVersion = rawKey[1]; //2
pks.reserved = BitConverter.ToUInt16(rawKey, 2); //0
pks.aiKeyAlg = BitConverter.ToUInt32(rawKey, 4); //8704
kb = (KeyBlob)pks.bType; //private //public
c = (Calg)pks.aiKeyAlg; //DSS_SIGN
if (kb != KeyBlob.PUBLICKEYBLOB && kb != KeyBlob.PRIVATEKEYBLOB)
{
throw new Exception("unsupported blob type");
}
dpk = new DSSPUBKEY();
//PRIV This must always be set to 0x32535344. the ASCII encoding of DSS2.
//PUB This must always be set to 0x31535344, the ASCII encoding of DSS1.
dpk.magic = BitConverter.ToUInt32(rawKey, 8); //844321604 //827544388
//Number of bits in the DSS key BLOB's prime, P.
dpk.bitlen = BitConverter.ToUInt32(rawKey, 12); //1024
uint byteLen = dpk.bitlen / 8; //128
this.SetSizeAndPosition(dpk.bitlen);
bool revBytes = true;
P = Format.GetBytes(this.rawKey, pPos, pLen, revBytes);
Q = Format.GetBytes(this.rawKey, qPos, qLen, revBytes);
G = Format.GetBytes(this.rawKey, gPos, gLen, revBytes);
if (kb == KeyBlob.PRIVATEKEYBLOB)
{
X = Format.GetBytes(this.rawKey, xyPos, xLen, revBytes);
PgenCounter = Format.GetBytes(this.rawKey, xPgenCounterPos, pgenCounterLen, revBytes);
Seed = Format.GetBytes(this.rawKey, xSeedPos, seedLen, revBytes);
}
if (kb == KeyBlob.PUBLICKEYBLOB)
{
Y = Format.GetBytes(this.rawKey, xyPos, yLen, revBytes);
PgenCounter = Format.GetBytes(this.rawKey, yPgenCounterPos, pgenCounterLen, revBytes);
Seed = Format.GetBytes(this.rawKey, ySeedPos, seedLen, revBytes);
}
ds = new DSSSEED();
byte [] baPcTemp = new byte[4];
Buffer.BlockCopy(PgenCounter, 0, baPcTemp, 0, PgenCounter.Length);
ds.counter = (uint)BitConverter.ToInt32(baPcTemp, 0);
ds.seed = (byte[])Seed.Clone();
Int64 bij = 0;
Int64 bip = BitConverter.ToInt64(P, 0);
Int64 biq = BitConverter.ToInt64(Q, 0);
bij = (bip - 1) / biq;
byte [] baJ = BitConverter.GetBytes(bij);
int len = baJ.Length;
int rem = (len % 4); //seems to be 4 byte blocks for J?
int pad = 0;
if (rem != 0)
{
pad = 4 - rem;
len = len + pad;
}
this.J = new byte[len];
Array.Copy(baJ, 0, this.J, pad, baJ.Length);
}
public void BuildRawKey(bool privateKey)
{
//build up rawKey byte[]
uint dsaMagic = 0;
uint caSize = 0;
uint bitLen = (uint)this.P.Length * 8;
this.SetSizeAndPosition(bitLen);
if (privateKey == true)
{
kb = KeyBlob.PRIVATEKEYBLOB;
caSize = privByteLen; //336
dsaMagic = 0x32535344; //ASCII encoding of "DSS2"
}
else //public
{
kb = KeyBlob.PUBLICKEYBLOB;
caSize = pubByteLen; //444
dsaMagic = 0x31535344; //ASCII encoding of "DSS1"
}
rawKey = new byte[caSize];
//PUBLICKEYSTRUC
rawKey[0] = (byte)kb; //bType
rawKey[1] = (byte)2; //bVersion
//reserved 2,3
c = Calg.DSS_SIGN;
byte [] baKeyAlg = BitConverter.GetBytes((uint)c); //aiKeyAlg
Buffer.BlockCopy(baKeyAlg, 0, rawKey, 4, 4);
pks = new PUBLICKEYSTRUC();
pks.bType = rawKey[0];
pks.bVersion = rawKey[1];
pks.reserved = BitConverter.ToUInt16(rawKey, 2);
pks.aiKeyAlg = BitConverter.ToUInt32(rawKey, 4);
//DSSPUBKEY
byte [] baMagic = BitConverter.GetBytes(dsaMagic); //magic
Buffer.BlockCopy(baMagic, 0, rawKey, 8, 4);
byte [] baBitlen = BitConverter.GetBytes(bitLen); //bitlen
Buffer.BlockCopy(baBitlen, 0, rawKey, 12, 4);
dpk = new DSSPUBKEY();
dpk.magic = BitConverter.ToUInt32(rawKey, 8);
dpk.bitlen = BitConverter.ToUInt32(rawKey, 12);
uint byteLen = dpk.bitlen / 8;
bool revBytes = true;
Format.SetBytes(this.rawKey, pPos, pLen, this.P, revBytes);
Format.SetBytes(this.rawKey, qPos, qLen, this.Q, revBytes);
Format.SetBytes(this.rawKey, gPos, gLen, this.G, revBytes);
if (privateKey == true)
{
Format.SetBytes(this.rawKey, xyPos, xLen, this.X, revBytes);
Format.SetBytes(this.rawKey, xPgenCounterPos, pgenCounterLen, this.PgenCounter, revBytes);
Format.SetBytes(this.rawKey, xSeedPos, seedLen, this.Seed, revBytes);
//this.Y = null;
}
else //public
{
Format.SetBytes(this.rawKey, xyPos, yLen, this.Y, revBytes);
Format.SetBytes(this.rawKey, yPgenCounterPos, pgenCounterLen, this.PgenCounter, revBytes);
Format.SetBytes(this.rawKey, ySeedPos, seedLen, this.Seed, revBytes);
this.X = null;
}
ds = new DSSSEED();
byte [] baPcTemp = new byte[4];
Buffer.BlockCopy(PgenCounter, 0, baPcTemp, 0, PgenCounter.Length);
//Array.Reverse(baPcTemp, 0, baPcTemp.Length);
ds.counter = (uint)BitConverter.ToInt32(baPcTemp, 0);
ds.seed = (byte[])Seed.Clone();
//nowhere to put J
//this.J = null;
}