public PgpSignature(PgpPacket FromPacket, PgpPublicKey PublicMasterKeyPacket, PgpPublicKey PublicKeyPacket, EncryptionServices Cryptography) : base(FromPacket) { Initialise(nSignatureType.SubkeyBinding); _PublicKeyPacket = PublicKeyPacket; _Cryptography = Cryptography; Parse(PublicMasterKeyPacket); }
public EncryptedDatabase(string sPath, EncryptionServices Cryptography = null) : base(sPath) { _abAesKey = null; _ltVariables = new List <DatabaseVariable>(); _ltProperties = new List <Property>(); _quVariablesStore = new Queue <DatabaseVariable>(); _Cryptography = Cryptography ?? new EncryptionServices(); }
public PgpSignature(PgpPacket FromPacket, PgpPublicKey PublicMasterKeyPacket, PgpUserId UserIdPacket, List <PgpToken> ltTokens, EncryptionServices Cryptography) : base(FromPacket) { Initialise(nSignatureType.PositiveCertification); _PublicKeyPacket = PublicMasterKeyPacket; _UserIdPacket = UserIdPacket; _Cryptography = Cryptography; Parse(_PublicKeyPacket, ltTokens); }
/// <summary>Constructor for OpenPGP keyring files.</summary> public PgpToken(byte[] abKeyBytes, List <PgpToken> ltTokens, EncryptionServices Cryptography) : this(Cryptography) { bool isPublicKey = true; int iPgpPacketPointer = 0; PgpPacket DecodedPgpPacket, RawPgpPacket; if (abKeyBytes != null) { _eStatus = nStatus.OK; while ((_eStatus == nStatus.OK) && (iPgpPacketPointer < abKeyBytes.Length - 2)) { RawPgpPacket = new PgpPacket(abKeyBytes, iPgpPacketPointer); if (RawPgpPacket.eStatus == PgpPacketBase.nStatus.OK) { switch (RawPgpPacket.ePacketTag) { case PgpPacket.nPacketTag.PrivateKey: case PgpPacket.nPacketTag.PrivateSubkey: DecodedPgpPacket = ParsePrivateKeyPacket(RawPgpPacket); break; case PgpPacket.nPacketTag.PublicKey: case PgpPacket.nPacketTag.PublicSubkey: DecodedPgpPacket = ParsePublicKeyPacket(RawPgpPacket); break; case PgpPacket.nPacketTag.Signature: DecodedPgpPacket = ParseSignaturePacket(RawPgpPacket, ltTokens); break; case PgpPacket.nPacketTag.UserId: DecodedPgpPacket = ParseUserIdPacket(RawPgpPacket); break; default: DecodedPgpPacket = null; Console.WriteLine("not implemented: ePacketTag=" + RawPgpPacket.ePacketTag.ToString()); break; } if ((DecodedPgpPacket == null) || (DecodedPgpPacket.eStatus != PgpPacketBase.nStatus.OK)) { _eStatus = nStatus.ParseErrorSub; } // else // Console.WriteLine(" Found ePacketTag=" + RawPgpPacket.ePacketTag.ToString() + " iHeaderLength=" + RawPgpPacket.iHeaderLength.ToString() + ", iDataLength=" + RawPgpPacket.iDataLength.ToString()); iPgpPacketPointer += (RawPgpPacket.iHeaderLength + RawPgpPacket.iPartialHeaders + RawPgpPacket.iDataLength); } else { _eStatus = nStatus.ParseErrorRaw; } } if (((_eStatus == nStatus.OK) && (iPgpPacketPointer != abKeyBytes.Length)) || (_ltSubkeys == null) || (_ltSubkeys.Count == 0)) { _eStatus = nStatus.ParseErrorRaw; } else { foreach (PgpSignature Subkey in _ltSubkeys) { isPublicKey = isPublicKey && (Subkey.PrivateKeyPacket == null); // one private key packet flags the whole token as private } _eType = isPublicKey ? nType.Public : nType.Private; } } }
/// <summary>Base constructor for initialisation.</summary> private PgpToken(EncryptionServices Cryptography) { _eStatus = nStatus.Undefined; _eType = nType.Undefined; _sSlotName = string.Empty; _TokenInfo = null; _UserIdPacket = null; _Cryptography = Cryptography; _KeyPacket = null; _ltSubkeys = new List <PgpSignature>(); }
/// <summary></summary> private void Initialise() { _iDBits = _iPBits = _iQBits = _iInverseQBits = _iOffsetSecretKey = 0; _eStringToKeyUsage = nStringToKeyUsage.Sha1; _eSymmetricKeyAlgorithm = nSymmetricKeyAlgorithm.Aes128; _eStringToKeySpecifier = nStringToKeySpecifier.SaltedAndIterated; _eHashAlgorithm = nHashAlgorithm.Sha1; _Cryptography = null; _PublicKey = null; _KeyParameters = new RSAParameters(); }
/// <summary></summary> private void Initialise(nSignatureType eSignatureType) { _abFingerprint = _abHashFingerprint = _abSignature = null; _iHashedLength = _iSignatureBits = 0; _eVerified = nVerified.Pending; _eSignatureType = eSignatureType; _eTranslatedKeyFlags = nTranslatedKeyFlags.None; _ePublicKeyAlgorithm = nPublicKeyAlgorithm.RsaEncryptOrSign; _eHashAlgorithm = nHashAlgorithm.Sha512; _PrivateKeyPacket = null; _PublicKeyPacket = null; _UserIdPacket = null; _Cryptography = null; _ltSubpackets = new List <PgpSignatureSubpacket>(); }
/// <summary></summary> public PgpPrivateKey(PgpPacket FromPacket, EncryptionServices Cryptography) : base(FromPacket) { PgpPublicKeyUtility KeyUtility; Initialise(); _Cryptography = Cryptography; KeyUtility = new PgpPublicKeyUtility(_abRawBytes); // extract the public key bytes _eStatus = KeyUtility.eStatus; if (_eStatus == nStatus.OK) { _PublicKey = new PgpPublicKey(new PgpPacket(KeyUtility.abRawBytes, 0)); // and turn them into a public key _KeyParameters.Exponent = KeyUtility.abExponent; _KeyParameters.Modulus = KeyUtility.abModulus; _eStatus = _PublicKey.eStatus; if (_eStatus == nStatus.OK) { _iOffsetSecretKey = _PublicKey.iHeaderLength + _PublicKey.iDataLength; _eStringToKeyUsage = (nStringToKeyUsage)_abRawBytes[_iOffsetSecretKey++]; if ((_eStringToKeyUsage == nStringToKeyUsage.Sha1) || (_eStringToKeyUsage == nStringToKeyUsage.Checksum)) { _eSymmetricKeyAlgorithm = (nSymmetricKeyAlgorithm)_abRawBytes[_iOffsetSecretKey++]; _eStringToKeySpecifier = (nStringToKeySpecifier)_abRawBytes[_iOffsetSecretKey++]; _eHashAlgorithm = (nHashAlgorithm)_abRawBytes[_iOffsetSecretKey++]; if ((_eSymmetricKeyAlgorithm == nSymmetricKeyAlgorithm.Unencrypted) || (_eSymmetricKeyAlgorithm == nSymmetricKeyAlgorithm.Aes128)) { if (_eStringToKeySpecifier == nStringToKeySpecifier.GnuDummy) { throw new NotImplementedException("eStringToKeySpecifier == nStringToKeySpecifier.GnuDummy"); } } else { _eStatus = nStatus.AlgorithmNotSupported; } } else { _eStatus = nStatus.AlgorithmNotSupported; } } } }
public PgpMessage(byte[] abMessageBytes, EncryptionServices Cryptography) : this(Cryptography) { int iPgpPacketPointer = 0; PgpPacket DecodedPgpPacket, RawPgpPacket; if (abMessageBytes != null) { _eStatus = nStatus.OK; while ((_eStatus == nStatus.OK) && (iPgpPacketPointer < abMessageBytes.Length - 2)) { RawPgpPacket = new PgpPacket(abMessageBytes, iPgpPacketPointer); if (RawPgpPacket.eStatus == PgpPacketBase.nStatus.OK) { switch (RawPgpPacket.ePacketTag) { case PgpPacket.nPacketTag.PublicKeyEncryptedKey: DecodedPgpPacket = ParsePublicKeyEncryptedKeyPacket(RawPgpPacket); break; case PgpPacket.nPacketTag.SymmetricallyEncryptedProtected: DecodedPgpPacket = new PgpSymmetricallyEncryptedDataPacket(RawPgpPacket); break; default: DecodedPgpPacket = null; Console.WriteLine("not implemented: ePacketTag=" + RawPgpPacket.ePacketTag.ToString()); break; } if ((DecodedPgpPacket == null) || (DecodedPgpPacket.eStatus != PgpPacketBase.nStatus.OK)) { _eStatus = nStatus.ParseErrorSub; } iPgpPacketPointer += (RawPgpPacket.iHeaderLength + RawPgpPacket.iPartialHeaders + RawPgpPacket.iDataLength); } else { _eStatus = nStatus.ParseErrorRaw; } } } if (((_eStatus == nStatus.OK) && (iPgpPacketPointer != abMessageBytes.Length))) { _eStatus = nStatus.ParseErrorRaw; } }
public PgpSignature(ISlotInfo SlotInfo, byte[] abId, PgpKeyFlags.nFlags eKeyFlags, byte[] abModulus, byte[] abExponent, EncryptionServices Cryptography) : base(nPacketTag.Signature) { PgpSignatureSubpacket NewSubpacket; Initialise((eKeyFlags & PgpKeyFlags.nFlags.Sign) == 0 ? nSignatureType.SubkeyBinding : nSignatureType.PositiveCertification); if ((SlotInfo == null) || (abId == null) || (abModulus == null) || (abExponent == null) || (Cryptography == null)) { _eStatus = nStatus.MissingArgument; } else { _eStatus = nStatus.OK; _Cryptography = Cryptography; _PublicKeyPacket = new PgpPublicKey(SlotInfo, abId, (eKeyFlags & PgpKeyFlags.nFlags.Sign) == 0 ? nPacketTag.PublicSubkey : nPacketTag.PublicKey, DateTime.Now, nPublicKeyAlgorithm.RsaEncryptOrSign, abModulus, abExponent); NewSubpacket = new PgpKeyFlags(eKeyFlags); _ltSubpackets.Add(NewSubpacket); _eTranslatedKeyFlags = TranslateKeyFlags(); } }
public PgpAesWithCfb(byte[] abKey, byte[] abInitialisationVector, EncryptionServices Cryptography) { _abCfbInputVector = _abCfbOutputVector = null; _Cryptography = Cryptography; Reset(abKey, abInitialisationVector); }
/// <summary>Constructor for OpenPGP smard card hardware tokens.</summary> public PgpToken(ITokenInfo TokenInfo, EncryptionServices Cryptography) : this(Cryptography) { _TokenInfo = TokenInfo; }
private PgpMessage(EncryptionServices Cryptography) { _eStatus = nStatus.Undefined; _Cryptography = Cryptography; _ltPublicKeyEncryptedKeys = new List <PgpPublicKeyEncryptedKey>(); }