public static IntPtr DeriveKey(IntPtr prov, Calg algId, IntPtr hash, GenKeyParam flags) { IntPtr key; bool retVal = Crypto.CryptDeriveKey(prov, (uint)algId, hash, (uint)flags, out key); ErrCode ec = Error.HandleRetVal(retVal); return key; }
public RSACryptoServiceProvider(KeySpec keySpec, bool genKey) { IntPtr prov = IntPtr.Zero; IntPtr rsaKey = IntPtr.Zero; try { this.keySpec = keySpec; if (genKey == false) //faster { prov = Context.AcquireContext("rSaContainer"); rsaKey = Key.GetUserKey(prov, keySpec); } else //new key { prov = Context.AcquireContext("rSaContainerImp"); Calg calg = Calg.RSA_KEYX; if (keySpec == KeySpec.SIGNATURE) { calg = Calg.RSA_SIGN; } rsaKey = Key.GenKey(prov, calg, GenKeyParam.EXPORTABLE); } byte [] baPrivKey = Key.ExportKey(rsaKey, IntPtr.Zero, KeyBlob.PRIVATEKEYBLOB); _rsa = new Rsa(baPrivKey); } finally { Key.DestroyKey(rsaKey); Context.ReleaseContext(prov); } }
public static IntPtr DeriveKey(IntPtr prov, Calg algId, IntPtr hash, GenKeyParam flags) { IntPtr key; bool retVal = NativeMethods.CryptDeriveKey(prov, (uint)algId, hash, (uint)flags, out key); ErrCode ec = Error.HandleRetVal(retVal); return(key); }
//algId can also be AT_KEYEXCHANGE = 1, AT_SIGNATURE = 2, public static IntPtr GenKey(IntPtr prov, Calg algId, GenKeyParam flags) { IntPtr key; bool retVal = Crypto.CryptGenKey(prov, (uint)algId, (uint)flags, out key); ErrCode ec = Error.HandleRetVal(retVal); return(key); }
public static IntPtr ImportSessionKey(IntPtr prov, Calg algId, byte [] rawKey, bool reverse) { if(reverse == true) Array.Reverse(rawKey, 0, rawKey.Length); IntPtr nullKey = Key.ImportKey(prov, NullKey.PrivateKeyWithExponentOfOne, IntPtr.Zero, GenKeyParam.EXPORTABLE); IntPtr key = Key.GenKey(prov, algId, GenKeyParam.EXPORTABLE); byte [] baSessKey = Key.ExportKey(key, nullKey, KeyBlob.SIMPLEBLOB); Key.DestroyKey(key); Buffer.BlockCopy(rawKey, 0, baSessKey, 12, rawKey.Length); key = Key.ImportKey(prov, baSessKey, IntPtr.Zero, GenKeyParam.EXPORTABLE); Key.DestroyKey(nullKey); return key; }
public static IntPtr ImportSessionKey(IntPtr prov, Calg algId, byte [] rawKey, bool reverse) { if (reverse == true) { Array.Reverse(rawKey, 0, rawKey.Length); } IntPtr nullKey = Key.ImportKey(prov, NullKey.PrivateKeyWithExponentOfOne, IntPtr.Zero, GenKeyParam.EXPORTABLE); IntPtr key = Key.GenKey(prov, algId, GenKeyParam.EXPORTABLE); byte [] baSessKey = Key.ExportKey(key, nullKey, KeyBlob.SIMPLEBLOB); Key.DestroyKey(key); Buffer.BlockCopy(rawKey, 0, baSessKey, 12, rawKey.Length); key = Key.ImportKey(prov, baSessKey, IntPtr.Zero, GenKeyParam.EXPORTABLE); Key.DestroyKey(nullKey); return(key); }
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); } }
/// <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; }
/// <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 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; } }