private EncryptedValue EncryptData(byte[] data) { MemoryOutputStream bOut = new MemoryOutputStream(); Stream eOut = encryptor.BuildCipher(bOut).Stream; try { eOut.Write(data, 0, data.Length); BestHTTP.SecureProtocol.Org.BouncyCastle.Utilities.Platform.Dispose(eOut); } catch (IOException e) { throw new CrmfException("cannot process data: " + e.Message, e); } AlgorithmIdentifier intendedAlg = null; AlgorithmIdentifier symmAlg = (AlgorithmIdentifier)encryptor.AlgorithmDetails; DerBitString encSymmKey; try { encSymmKey = new DerBitString(wrapper.Wrap(((KeyParameter)encryptor.Key).GetKey()).Collect()); } catch (Exception e) { throw new CrmfException("cannot wrap key: " + e.Message, e); } AlgorithmIdentifier keyAlg = (AlgorithmIdentifier)wrapper.AlgorithmDetails; Asn1OctetString valueHint = null; DerBitString encValue = new DerBitString(bOut.ToArray()); return(new EncryptedValue(intendedAlg, symmAlg, encSymmKey, keyAlg, valueHint, encValue)); }
public static MetadataJavaField ToMetadata(this JavaField field) { var javaField = new MetadataJavaField { Name = field.Name, Type = field.Type.GetSignature() }; if (field.ConstantValue != null) { using var stream = new MemoryStream(); using var ms = new MemoryOutputStream(stream); using var dos = new DataOutputStream(ms); field.ConstantValue.Dump(dos); //Write the original string there to be able to create a new constantpool from metadata if (field.ConstantValue is ConstantString constantString) { dos.WriteUTF(constantString.GetBytes(field.ConstantPool)); } javaField.ConstantValue = stream.ToArray(); } return(javaField); }
public byte[] GetEncoded() { MemoryOutputStream bOut = new MemoryOutputStream(); this.Encode(bOut); return(bOut.ToArray()); }
private CmsEnvelopedData doGenerate( ICmsTypedData content, ICipherBuilderWithKey<AlgorithmIdentifier> contentEncryptor) { Asn1EncodableVector recipientInfos = new Asn1EncodableVector(); AlgorithmIdentifier encAlgId; Asn1OctetString encContent; MemoryOutputStream bOut = new MemoryOutputStream(); try { ICipher cOut = contentEncryptor.BuildCipher(bOut); content.Write(cOut.Stream); cOut.Stream.Close(); } catch (IOException e) { throw new CmsException(e.Message, e); } byte[] encryptedContent = bOut.ToArray(); encAlgId = contentEncryptor.AlgorithmDetails; encContent = new BerOctetString(encryptedContent); ISymmetricKey encKey = contentEncryptor.Key; for (IEnumerator<IRecipientInfoGenerator> it = recipientInfoGenerators.GetEnumerator(); it.MoveNext();) { IRecipientInfoGenerator recipient = (IRecipientInfoGenerator)it.Current; recipientInfos.Add(recipient.Generate(encKey)); } EncryptedContentInfo eci = new EncryptedContentInfo( content.ContentType, encAlgId, encContent); Asn1Set unprotectedAttrSet = null; if (unprotectedAttributeGenerator != null) { Asn1.Cms.AttributeTable attrTable = unprotectedAttributeGenerator.GetAttributes(new Dictionary<string, object>()); unprotectedAttrSet = new BerSet(attrTable.ToAsn1EncodableVector()); } ContentInfo contentInfo = new ContentInfo( CmsObjectIdentifiers.EnvelopedData, new EnvelopedData(originatorInfo, new DerSet(recipientInfos), eci, unprotectedAttrSet)); return new CmsEnvelopedData(contentInfo); }
public IBlockResult Wrap(byte[] keyData) { MemoryOutputStream mOut = new MemoryOutputStream(); ICipher keyCipher = cipherBuilder.BuildCipher(mOut); keyCipher.Stream.Write(keyData, 0, keyData.Length); keyCipher.Stream.Close(); return(new SimpleBlockResult(mOut.ToArray())); }
public IBlockResult Unwrap(byte[] cipherText, int offset, int length) { MemoryOutputStream mOut = new MemoryOutputStream(); ICipher keyCipher = cipherBuilder.BuildCipher(mOut); keyCipher.Stream.Write(cipherText, offset, length); keyCipher.Stream.Close(); return(new SimpleBlockResult(mOut.ToArray())); }
public async Task FileWriteStreamRandomSeekTestAsync() { byte[] buffer = GetRandomBuffer(3 * 1024 * 1024); CloudFileShare share = GetRandomShareReference(); share.ServiceClient.DefaultRequestOptions.ParallelOperationThreadCount = 2; try { await share.CreateAsync(); CloudFile file = share.GetRootDirectoryReference().GetFileReference("file1"); using (MemoryStream wholeFile = new MemoryStream()) { using (var writeStream = await file.OpenWriteAsync(buffer.Length)) { Stream fileStream = writeStream; await fileStream.WriteAsync(buffer, 0, buffer.Length); await wholeFile.WriteAsync(buffer, 0, buffer.Length); Random random = new Random(); for (int i = 0; i < 10; i++) { int offset = random.Next(buffer.Length); TestHelper.SeekRandomly(fileStream, offset); await fileStream.WriteAsync(buffer, 0, buffer.Length - offset); wholeFile.Seek(offset, SeekOrigin.Begin); await wholeFile.WriteAsync(buffer, 0, buffer.Length - offset); } } wholeFile.Seek(0, SeekOrigin.End); await file.FetchAttributesAsync(); Assert.IsNull(file.Properties.ContentMD5); using (MemoryOutputStream downloadedFile = new MemoryOutputStream()) { await file.DownloadToStreamAsync(downloadedFile); TestHelper.AssertStreamsAreEqual(wholeFile, downloadedFile.UnderlyingStream); } } } finally { share.DeleteIfExistsAsync().Wait(); } }
public void WriteByte_ByteIsWritten() { // Arrange var result = new byte[1]; IOutputStream memoryOutputStream = new MemoryOutputStream(result); var expectedData = new byte[] { 1 }; // Act memoryOutputStream.WriteByte(1); memoryOutputStream.Dispose(); // Assert Assert.True(result.SequenceEqual(expectedData)); }
public void WriteBlock_WriteAllFromArray_AllDataIsWritten() { // Arrange var result = new byte[3]; IOutputStream memoryOutputStream = new MemoryOutputStream(result); var data = new byte[] { 1, 2, 3 }; // Act memoryOutputStream.WriteBlock(data, size: ( uint )data.Length); memoryOutputStream.Dispose(); // Assert Assert.True(result.SequenceEqual(data)); }
public void WriteBlock_WriteFirstByteFromArray_WrittenOnlyOneByte() { // Arrange var result = new byte[1]; IOutputStream memoryOutputStream = new MemoryOutputStream(result); var expectedData = new byte[] { 1 }; // Act memoryOutputStream.WriteBlock(new byte[] { 1, 2 }, size: 1); memoryOutputStream.Dispose(); // Assert Assert.True(result.SequenceEqual(expectedData)); }
private CmsEncryptedData doGenerate( ICmsTypedData content, ICipherBuilder <AlgorithmIdentifier> contentEncryptor) { AlgorithmIdentifier encAlgId; Asn1OctetString encContent; MemoryOutputStream bOut = new MemoryOutputStream(); try { ICipher cipher = contentEncryptor.BuildCipher(bOut); content.Write(cipher.Stream); cipher.Stream.Close(); } catch (IOException) { throw new CmsException(""); } byte[] encryptedContent = bOut.ToArray(); encAlgId = contentEncryptor.AlgorithmDetails; encContent = new BerOctetString(encryptedContent); EncryptedContentInfo eci = new EncryptedContentInfo( content.ContentType, encAlgId, encContent); Asn1Set unprotectedAttrSet = null; if (unprotectedAttributeGenerator != null) { Asn1.Cms.AttributeTable attrTable = unprotectedAttributeGenerator.GetAttributes(new Dictionary <string, object>()); unprotectedAttrSet = new BerSet(attrTable.ToAsn1EncodableVector()); } ContentInfo contentInfo = new ContentInfo( CmsObjectIdentifiers.EncryptedData, new EncryptedData(eci, unprotectedAttrSet)); return(new CmsEncryptedData(contentInfo)); }
/// <summary> /// Create the encrypted private key info using the passed in encryptor. /// </summary> /// <param name="encryptor">The encryptor to use.</param> /// <returns>An encrypted private key info containing the original private key info.</returns> public Pkcs8EncryptedPrivateKeyInfo Build( ICipherBuilder encryptor) { try { MemoryStream bOut = new MemoryOutputStream(); ICipher cOut = encryptor.BuildCipher(bOut); byte[] keyData = privateKeyInfo.GetEncoded(); Stream str = cOut.Stream; str.Write(keyData, 0, keyData.Length); BestHTTP.SecureProtocol.Org.BouncyCastle.Utilities.Platform.Dispose(str); return(new Pkcs8EncryptedPrivateKeyInfo(new EncryptedPrivateKeyInfo((AlgorithmIdentifier)encryptor.AlgorithmDetails, bOut.ToArray()))); } catch (IOException) { throw new InvalidOperationException("cannot encode privateKeyInfo"); } }
/// <summary> /// Create the encrypted private key info using the passed in encryptor. /// </summary> /// <param name="encryptor">The encryptor to use.</param> /// <returns>An encrypted private key info containing the original private key info.</returns> public Pkcs8EncryptedPrivateKeyInfo Build( ICipherBuilder encryptor) { try { MemoryStream bOut = new MemoryOutputStream(); ICipher cOut = encryptor.BuildCipher(bOut); byte[] keyData = privateKeyInfo.GetEncoded(); using (var str = cOut.Stream) { str.Write(keyData, 0, keyData.Length); } return(new Pkcs8EncryptedPrivateKeyInfo(new EncryptedPrivateKeyInfo((AlgorithmIdentifier)encryptor.AlgorithmDetails, bOut.ToArray()))); } catch (IOException) { throw new InvalidOperationException("cannot encode privateKeyInfo"); } }
public async Task FileWriteStreamFlushTestAsync() { byte[] buffer = GetRandomBuffer(512); CloudFileShare share = GetRandomShareReference(); try { await share.CreateAsync(); CloudFile file = share.GetRootDirectoryReference().GetFileReference("file1"); file.StreamWriteSizeInBytes = 1024; using (MemoryStream wholeFile = new MemoryStream()) { FileRequestOptions options = new FileRequestOptions() { StoreFileContentMD5 = true }; OperationContext opContext = new OperationContext(); using (var fileStream = await file.OpenWriteAsync(4 * 512, null, options, opContext)) { for (int i = 0; i < 3; i++) { await fileStream.WriteAsync(buffer, 0, buffer.Length); await wholeFile.WriteAsync(buffer, 0, buffer.Length); } #if NETCORE // todo: Make some other better logic for this test to be reliable. System.Threading.Thread.Sleep(500); #endif Assert.AreEqual(2, opContext.RequestResults.Count); await fileStream.FlushAsync(); Assert.AreEqual(3, opContext.RequestResults.Count); await fileStream.FlushAsync(); Assert.AreEqual(3, opContext.RequestResults.Count); await fileStream.WriteAsync(buffer, 0, buffer.Length); await wholeFile.WriteAsync(buffer, 0, buffer.Length); Assert.AreEqual(3, opContext.RequestResults.Count); await fileStream.CommitAsync(); Assert.AreEqual(5, opContext.RequestResults.Count); } Assert.AreEqual(5, opContext.RequestResults.Count); using (MemoryOutputStream downloadedFile = new MemoryOutputStream()) { await file.DownloadToStreamAsync(downloadedFile); TestHelper.AssertStreamsAreEqual(wholeFile, downloadedFile.UnderlyingStream); } } } finally { share.DeleteIfExistsAsync().Wait(); } }
private static SecretKeyPacket buildSecretKeyPacket(bool isMasterKey, PgpPrivateKey privKey, PgpPublicKey pubKey, IPbeSecretKeyEncryptor keyEncryptor) { BcpgObject secKey = (BcpgObject)privKey.Key; if (secKey == null) { if (isMasterKey) { return(new SecretKeyPacket(pubKey.publicPk, SymmetricKeyAlgorithmTag.Null, null, null, new byte[0])); } else { return(new SecretSubkeyPacket(pubKey.publicPk, SymmetricKeyAlgorithmTag.Null, null, null, new byte[0])); } } try { MemoryOutputStream bOut = new MemoryOutputStream(); BcpgOutputStream pOut = new BcpgOutputStream(bOut); pOut.WriteObject(secKey); byte[] keyData = bOut.ToArray(); byte[] checkData = checksum(keyEncryptor.ChecksumCalculatorFactory, keyData, keyData.Length); pOut.Write(checkData, 0, checkData.Length); PgpPbeKeyEncryptionParameters encParams = keyEncryptor.AlgorithmDetails; SymmetricKeyAlgorithmTag encAlgorithm = (keyEncryptor != null) ? encParams.Algorithm : SymmetricKeyAlgorithmTag.Null; if (encAlgorithm != SymmetricKeyAlgorithmTag.Null) { keyData = bOut.ToArray(); // include checksum byte[] encData = keyEncryptor.Wrap(keyData).Collect(); byte[] iv = encParams.GetIV(); S2k s2k = encParams.S2k; int s2kUsage; if (keyEncryptor.ChecksumCalculatorFactory != null) { if (keyEncryptor.ChecksumCalculatorFactory.AlgorithmDetails.Algorithm != HashAlgorithmTag.Sha1) { throw new PgpException("only SHA1 supported for key checksum calculations."); } s2kUsage = SecretKeyPacket.UsageSha1; } else { s2kUsage = SecretKeyPacket.UsageChecksum; } if (isMasterKey) { return(new SecretKeyPacket(pubKey.publicPk, encAlgorithm, s2kUsage, s2k, iv, encData)); } else { return(new SecretSubkeyPacket(pubKey.publicPk, encAlgorithm, s2kUsage, s2k, iv, encData)); } } else { if (isMasterKey) { return(new SecretKeyPacket(pubKey.publicPk, encAlgorithm, null, null, bOut.ToArray())); } else { return(new SecretSubkeyPacket(pubKey.publicPk, encAlgorithm, null, null, bOut.ToArray())); } } } catch (PgpException e) { throw e; } catch (Exception e) { throw new PgpException("Exception encrypting key", e); } }
public async Task FileWriteStreamBasicTestAsync() { byte[] buffer = GetRandomBuffer(6 * 512); #if NETCORE MD5 hasher = MD5.Create(); #else CryptographicHash hasher = HashAlgorithmProvider.OpenAlgorithm("MD5").CreateHash(); #endif CloudFileShare share = GetRandomShareReference(); share.ServiceClient.DefaultRequestOptions.ParallelOperationThreadCount = 2; try { await share.CreateAsync(); CloudFile file = share.GetRootDirectoryReference().GetFileReference("file1"); file.StreamWriteSizeInBytes = 8 * 512; using (MemoryStream wholeFile = new MemoryStream()) { FileRequestOptions options = new FileRequestOptions() { StoreFileContentMD5 = true, }; using (var writeStream = await file.OpenWriteAsync(buffer.Length * 3, null, options, null)) { Stream fileStream = writeStream; for (int i = 0; i < 3; i++) { await fileStream.WriteAsync(buffer, 0, buffer.Length); await wholeFile.WriteAsync(buffer, 0, buffer.Length); Assert.AreEqual(wholeFile.Position, fileStream.Position); #if !NETCORE hasher.Append(buffer.AsBuffer()); #endif } await fileStream.FlushAsync(); } #if NETCORE string md5 = Convert.ToBase64String(hasher.ComputeHash(wholeFile.ToArray())); #else string md5 = CryptographicBuffer.EncodeToBase64String(hasher.GetValueAndReset()); #endif await file.FetchAttributesAsync(); Assert.AreEqual(md5, file.Properties.ContentMD5); using (MemoryOutputStream downloadedFile = new MemoryOutputStream()) { await file.DownloadToStreamAsync(downloadedFile); TestHelper.AssertStreamsAreEqual(wholeFile, downloadedFile.UnderlyingStream); } await TestHelper.ExpectedExceptionAsync <ArgumentException>( async() => await file.OpenWriteAsync(null, null, options, null), "OpenWrite with StoreFileContentMD5 on an existing file should fail"); using (var writeStream = await file.OpenWriteAsync(null)) { Stream fileStream = writeStream; fileStream.Seek(buffer.Length / 2, SeekOrigin.Begin); wholeFile.Seek(buffer.Length / 2, SeekOrigin.Begin); for (int i = 0; i < 2; i++) { fileStream.Write(buffer, 0, buffer.Length); wholeFile.Write(buffer, 0, buffer.Length); Assert.AreEqual(wholeFile.Position, fileStream.Position); } await fileStream.FlushAsync(); } await file.FetchAttributesAsync(); Assert.AreEqual(md5, file.Properties.ContentMD5); using (MemoryOutputStream downloadedFile = new MemoryOutputStream()) { options.DisableContentMD5Validation = true; await file.DownloadToStreamAsync(downloadedFile, null, options, null); TestHelper.AssertStreamsAreEqual(wholeFile, downloadedFile.UnderlyingStream); } } } finally { share.DeleteAsync().Wait(); } }
/** * generate a signed object that for a CMS Signed Data * object - if encapsulate is true a copy * of the message will be included in the signature. The content type * is set according to the OID represented by the string signedContentType. */ public CmsSignedData Generate( // FIXME Avoid accessing more than once to support CmsProcessableInputStream ICmsTypedData content, bool encapsulate) { // TODO // if (signerInfs.isEmpty()) // { // /* RFC 3852 5.2 // * "In the degenerate case where there are no signers, the // * EncapsulatedContentInfo value being "signed" is irrelevant. In this // * case, the content type within the EncapsulatedContentInfo value being // * "signed" MUST be id-data (as defined in section 4), and the content // * field of the EncapsulatedContentInfo value MUST be omitted." // */ // if (encapsulate) // { // throw new IllegalArgumentException("no signers, encapsulate must be false"); // } // if (!DATA.equals(eContentType)) // { // throw new IllegalArgumentException("no signers, eContentType must be id-data"); // } // } // // if (!DATA.equals(eContentType)) // { // /* RFC 3852 5.3 // * [The 'signedAttrs']... // * field is optional, but it MUST be present if the content type of // * the EncapsulatedContentInfo value being signed is not id-data. // */ // // TODO signedAttrs must be present for all signers // } Asn1EncodableVector digestAlgs = new Asn1EncodableVector(); Asn1EncodableVector signerInfos = new Asn1EncodableVector(); _digests.Clear(); // clear the current preserved digest state // // add the precalculated SignerInfo objects. // for (IEnumerator it = _signers.GetEnumerator(); it.MoveNext();) { SignerInformation signer = (SignerInformation)it.Current; digestAlgs.Add(CmsUtilities.fixAlgID(signer.DigestAlgorithmID)); // TODO Verify the content type and calculated digest match the precalculated SignerInfo signerInfos.Add(signer.ToAsn1Structure()); } // // add the SignerInfo objects // DerObjectIdentifier contentTypeOID = content.ContentType; Asn1OctetString octs = null; if (content.GetContent() != null) { MemoryOutputStream bOut = null; if (encapsulate) { bOut = new MemoryOutputStream(); } Stream cOut = CmsUtilities.attachSignersToOutputStream(_signerGens, bOut); // Just in case it's unencapsulated and there are no signers! cOut = CmsUtilities.getSafeOutputStream(cOut); try { content.Write(cOut); cOut.Close(); } catch (IOException e) { throw new CmsException("data processing exception: " + e.Message, e); } if (encapsulate) { octs = new BerOctetString(bOut.ToArray()); } } for (IEnumerator it = _signerGens.GetEnumerator(); it.MoveNext();) { SignerInfoGenerator sGen = (SignerInfoGenerator)it.Current; SignerInfo inf = sGen.Generate(contentTypeOID); digestAlgs.Add(inf.DigestAlgorithm); signerInfos.Add(inf); byte[] calcDigest = sGen.getCalculatedDigest(); if (calcDigest != null) { _digests.Add(inf.DigestAlgorithm.Algorithm.Id, calcDigest); } } Asn1Set certificates = null; if (_certs.Count != 0) { certificates = CmsUtilities.CreateBerSetFromList(_certs); } Asn1Set certrevlist = null; if (_crls.Count != 0) { certrevlist = CmsUtilities.CreateBerSetFromList(_crls); } ContentInfo encInfo = new ContentInfo(contentTypeOID, octs); SignedData sd = new SignedData( new DerSet(digestAlgs), encInfo, certificates, certrevlist, new DerSet(signerInfos)); ContentInfo contentInfo = new ContentInfo( CmsObjectIdentifiers.SignedData, sd); return(new CmsSignedData(content, contentInfo)); }
private PemObject createPemObject(Object o) { String type; byte[] encoding; if (o is PemObject) { return((PemObject)o); } if (o is PemObjectGenerator) { return(((PemObjectGenerator)o).Generate()); } if (o is X509Certificate) { type = "CERTIFICATE"; encoding = ((X509Certificate)o).GetEncoded(); } else if (o is X509Crl) { type = "X509 CRL"; encoding = ((X509Crl)o).GetEncoded(); } else if (o is X509TrustedCertificateBlock) { type = "TRUSTED CERTIFICATE"; encoding = ((X509TrustedCertificateBlock)o).GetEncoded(); } else if (o is PrivateKeyInfo) { PrivateKeyInfo info = (PrivateKeyInfo)o; DerObjectIdentifier algOID = info.PrivateKeyAlgorithm.Algorithm; if (algOID.Equals(PkcsObjectIdentifiers.RsaEncryption)) { type = "RSA PRIVATE KEY"; encoding = info.ParsePrivateKey().ToAsn1Object().GetEncoded(); } else if (algOID.Equals(dsaOids[0]) || algOID.Equals(dsaOids[1])) { type = "DSA PRIVATE KEY"; DsaParameter p = DsaParameter.GetInstance(info.PrivateKeyAlgorithm.Parameters); Asn1EncodableVector v = new Asn1EncodableVector(); v.Add(new DerInteger(0)); v.Add(new DerInteger(p.P)); v.Add(new DerInteger(p.Q)); v.Add(new DerInteger(p.G)); BigInteger x = DerInteger.GetInstance(info.ParsePrivateKey()).Value; BigInteger y = p.G.ModPow(x, p.P); v.Add(new DerInteger(y)); v.Add(new DerInteger(x)); encoding = new DerSequence(v).GetEncoded(); } else if (algOID.Equals(X9ObjectIdentifiers.IdECPublicKey)) { type = "EC PRIVATE KEY"; encoding = info.ParsePrivateKey().ToAsn1Object().GetEncoded(); } else { type = "PRIVATE KEY"; encoding = info.GetEncoded(); } } else if (o is SubjectPublicKeyInfo) { type = "PUBLIC KEY"; encoding = ((SubjectPublicKeyInfo)o).GetEncoded(); } /* * else if (o is X509AttributeCertificateHolder) * { * type = "ATTRIBUTE CERTIFICATE"; * encoding = ((X509AttributeCertificateHolder)o).getEncoded(); * } */ else if (o is Pkcs8EncryptedPrivateKeyInfo) { type = "ENCRYPTED PRIVATE KEY"; encoding = ((Pkcs8EncryptedPrivateKeyInfo)o).GetEncoded(); } else if (o is Pkcs10CertificationRequest) { type = "CERTIFICATE REQUEST"; encoding = ((Pkcs10CertificationRequest)o).GetEncoded(); } else if (o is ContentInfo) { type = "PKCS7"; encoding = ((ContentInfo)o).GetEncoded(); } else { throw new PemGenerationException("unknown object passed - can't encode."); } if (encryptorBuilder != null) { String dekAlgName = Platform.ToUpperInvariant(encryptorBuilder.AlgorithmDetails.Info); // Note: For backward compatibility if (dekAlgName.StartsWith("DESEDE")) { dekAlgName = "DES-EDE3-CBC"; } MemoryOutputStream bOut = new MemoryOutputStream(); ICipher encryptor = encryptorBuilder.BuildCipher(bOut); using (var stream = encryptor.Stream) { stream.Write(encoding, 0, encoding.Length); } byte[] encData = bOut.ToArray(); IList headers = Platform.CreateArrayList(); headers.Add(new PemHeader("Proc-Type", "4,ENCRYPTED")); headers.Add(new PemHeader("DEK-Info", encryptorBuilder.AlgorithmDetails.Info)); return(new PemObject(type, headers, encData)); } return(new PemObject(type, encoding)); }