--- product: Chilkat product_version: 11.7.0 language: pascal language_label: Lazarus Pascal class: Mime license: bundle deprecated: false reference_html: https://www.chilkatsoft.com/refdoc/pascal_MimeRef.html --- # Chilkat Mime — Lazarus Pascal — v11.7.0 > Chilkat 11.7.0 · language=pascal · class=Mime > Other versions: replace `11.7.0` in this URL. Other languages: `https://www.chilkatsoft.com/ai-docs/v/11.7.0//classes/Mime.md`. > Language-wide rules (install, unlock, error model, strings/bytes): `https://www.chilkatsoft.com/ai-docs/v/11.7.0/pascal/guide.md`. ## Purpose **Build, parse, modify, serialize, secure, and inspect MIME and S/MIME data.** `Mime` provides low-level MIME and S/MIME handling for applications that need direct control over MIME structure, headers, body content, encodings, multipart relationships, attachments, and PKCS7/CMS security layers. It can load, create, inspect, modify, serialize, and save MIME messages; build multipart structures; manage headers and content-transfer encodings; extract attachments; convert MIME to and from XML; and sign, verify, encrypt, decrypt, or unwrap S/MIME content. **Create and load MIME** Build MIME content programmatically or load existing MIME from strings, files, byte data, or other application sources. **Headers and body content** Read, add, replace, or remove MIME headers, set body content, and control content types, charsets, and transfer encodings. **Multipart structures** Create and inspect multipart MIME trees such as mixed, alternative, related, signed, encrypted, and nested MIME structures. **Attachments and parts** Add, locate, extract, remove, or inspect MIME parts and attachments, including filenames and encoded body data. **S/MIME security** Sign, verify, encrypt, decrypt, unwrap, and inspect PKCS7/CMS S/MIME layers using certificates and private keys. **Serialization and XML** Emit MIME text, save MIME to files, or convert MIME to and from XML for structured inspection, transformation, or storage. **Common pattern:** Use `Mime` when an application needs low-level control over MIME parts, headers, encodings, multipart layout, or S/MIME security. For ordinary email composition and message-level operations, use `Email`; use `Mime` when you need to work closer to the raw MIME structure. **Initial state:** A new `Mime` object has no headers or child parts. Its string serialization consists only of the blank header/body separator (`CRLF CRLF`) until content is added. **MIME parsing is semantic, not byte-preserving.** Loading and reserializing can unfold headers, normalize parameter quoting and transfer encodings, use CRLF for generated headers and multipart framing, and discard multipart preamble or epilogue text. Use byte-oriented methods such as `LoadMimeBd` and `GetMimeBd` when arbitrary 8-bit bytes or embedded NUL bytes must be preserved. For an extended overview, see [Mime Class Overview](https://www.chilkatsoft.com/mime_class_overview.asp). ## Object creation, unlocking and error handling **Create / Free** ```pascal uses Chilkat.Mime; var obj: TMime; begin obj := TMime.Create; try if not obj.IsValid then raise Exception.Create('Failed to create a TMime instance.'); // ... use obj ... finally obj.Free; end; end; ``` `constructor Create;` Allocates the underlying CkMime object and returns a new TMime instance. Simply adding **Chilkat.Mime** to the unit's `uses` clause is enough to locate and bind to the Chilkat shared library (DLL / .so / .dylib) at runtime — no separate load step is required. Check `obj.IsValid` after calling `Create`; it is `False` if the underlying library could not be found/loaded or the object could not be allocated (for example, when unlicensed). `destructor Destroy; override;` Every TMime created by calling `Create` should eventually be released by calling `.Free` (inherited from `TObject`). The destructor automatically disposes the underlying CkMime handle. A native (unmanaged) memory leak occurs if the object is never freed. Call `Global.UnlockBundle` once at the start of the program, before using this or any other Chilkat class. Any string unlocks a fully functional 30-day trial; a purchased unlock code is used in production. See `guide.md` for the exact code in Lazarus Pascal. ## Members common to every Chilkat class Documented once per language in `common-members.md`; listed here so this page is self-contained. | Property | Signature | Access | Meaning | |---|---|---|---| | `DebugLogFilePath` | `property DebugLogFilePath: string read GetDebugLogFilePath write SetDebugLogFilePath;` | read/write | If set to a file path, this property logs the LastErrorText of each Chilkat method or property call to the specified file. | | `LastErrorHtml` | `property LastErrorHtml: string read GetLastErrorHtml;` | read-only | Provides HTML-formatted information about the last called method or property. | | `LastErrorText` | `property LastErrorText: string read GetLastErrorText;` | read-only | Provides plain text information about the last called method or property. | | `LastErrorXml` | `property LastErrorXml: string read GetLastErrorXml;` | read-only | Provides XML-formatted information about the last called method or property. | | `LastMethodSuccess` | `property LastMethodSuccess: Boolean read GetLastMethodSuccess write SetLastMethodSuccess;` | read/write | Indicates the success or failure of the most recent method call: `True` means success, `False` means failure. | | `VerboseLogging` | `property VerboseLogging: Boolean read GetVerboseLogging write SetVerboseLogging;` | read/write | If set to `True`, then the contents of LastErrorText (or LastErrorXml, or LastErrorHtml) may contain more verbose information. | | `Version` | `property Version: string read GetVersion;` | read-only | Version of the component/library, such as "10.1.0" | ## Member index | Member | Kind | Signature | |---|---|---| | `Boundary` | property, read/write | `property Boundary: string read GetBoundary write SetBoundary;` | | `Charset` | property, read/write | `property Charset: string read GetCharset write SetCharset;` | | `CmsOptions` | property, read/write | `property CmsOptions: string read GetCmsOptions write SetCmsOptions;` | | `ContentType` | property, read/write | `property ContentType: string read GetContentType write SetContentType;` | | `CurrentDateTime` | property, read-only | `property CurrentDateTime: string read GetCurrentDateTime;` | | `Disposition` | property, read/write | `property Disposition: string read GetDisposition write SetDisposition;` | | `Encoding` | property, read/write | `property Encoding: string read GetEncoding write SetEncoding;` | | `Filename` | property, read/write | `property Filename: string read GetFilename write SetFilename;` | | `Micalg` | property, read/write | `property Micalg: string read GetMicalg write SetMicalg;` | | `Name` | property, read/write | `property Name: string read GetName write SetName;` | | `NumDecryptCerts` | property, read-only | `property NumDecryptCerts: Integer read GetNumDecryptCerts;` | | `NumHeaderFields` | property, read-only | `property NumHeaderFields: Integer read GetNumHeaderFields;` | | `NumParts` | property, read-only | `property NumParts: Integer read GetNumParts;` | | `NumSignerCerts` | property, read-only | `property NumSignerCerts: Integer read GetNumSignerCerts;` | | `OaepHash` | property, read/write | `property OaepHash: string read GetOaepHash write SetOaepHash;` | | `OaepMgfHash` | property, read/write | `property OaepMgfHash: string read GetOaepMgfHash write SetOaepMgfHash;` | | `OaepPadding` | property, read/write | `property OaepPadding: Boolean read GetOaepPadding write SetOaepPadding;` | | `Pkcs7CryptAlg` | property, read/write | `property Pkcs7CryptAlg: string read GetPkcs7CryptAlg write SetPkcs7CryptAlg;` | | `Pkcs7KeyLength` | property, read/write | `property Pkcs7KeyLength: Integer read GetPkcs7KeyLength write SetPkcs7KeyLength;` | | `Protocol` | property, read/write | `property Protocol: string read GetProtocol write SetProtocol;` | | `SigningAlg` | property, read/write | `property SigningAlg: string read GetSigningAlg write SetSigningAlg;` | | `SigningHashAlg` | property, read/write | `property SigningHashAlg: string read GetSigningHashAlg write SetSigningHashAlg;` | | `UncommonOptions` | property, read/write | `property UncommonOptions: string read GetUncommonOptions write SetUncommonOptions;` | | `UnwrapExtras` | property, read/write | `property UnwrapExtras: Boolean read GetUnwrapExtras write SetUnwrapExtras;` | | `UseMmDescription` | property, read/write | `property UseMmDescription: Boolean read GetUseMmDescription write SetUseMmDescription;` | | `UseXPkcs7` | property, read/write | `property UseXPkcs7: Boolean read GetUseXPkcs7 write SetUseXPkcs7;` | | `AddContentLength` | method | `procedure AddContentLength;` | | `AddDecryptCert` | method | `// cert is a TCert object. function AddDecryptCert(cert: TChilkatBase): Boolean;` | | `AddDetachedSignature` | method | `// cert is a TCert object. function AddDetachedSignature(cert: TChilkatBase): Boolean;` | | `AddDetachedSignature2` | method | `// cert is a TCert object. function AddDetachedSignature2(cert: TChilkatBase;     transferHeaderFields: Boolean): Boolean;` | | `AddDetachedSignaturePk` | method | `// cert is a TCert object. // privateKey is a TPrivateKey object. function AddDetachedSignaturePk(cert: TChilkatBase;     privateKey: TChilkatBase): Boolean;` | | `AddDetachedSignaturePk2` | method | `// cert is a TCert object. // privateKey is a TPrivateKey object. function AddDetachedSignaturePk2(cert: TChilkatBase;     privateKey: TChilkatBase;     transferHeaderFields: Boolean): Boolean;` | | `AddEncryptCert` | method | `// cert is a TCert object. function AddEncryptCert(cert: TChilkatBase): Boolean;` | | `AddHeaderField` | method | `function AddHeaderField(const name: string;     const value: string): Boolean;` | | `AddPfxSourceBd` | method | `// bd is a TBinData object. function AddPfxSourceBd(bd: TChilkatBase;     const password: string): Boolean;` | | `AddPfxSourceFile` | method | `function AddPfxSourceFile(const pfxFilePath: string;     const password: string): Boolean;` | | `AppendPart` | method | `// mime is a TMime object. function AppendPart(mime: TChilkatBase): Boolean;` | | `AppendPartFromFile` | method | `function AppendPartFromFile(const filename: string): Boolean;` | | `AsnBodyToXml` | method | `function AsnBodyToXml: string;` | | `ClearEncryptCerts` | method | `procedure ClearEncryptCerts;` | | `ContainsEncryptedParts` | method | `function ContainsEncryptedParts: Boolean;` | | `ContainsSignedParts` | method | `function ContainsSignedParts: Boolean;` | | `Convert8Bit` | method | `procedure Convert8Bit;` | | `ConvertToMultipartAlt` | method | `function ConvertToMultipartAlt: Boolean;` | | `ConvertToMultipartMixed` | method | `function ConvertToMultipartMixed: Boolean;` | | `ConvertToSigned` | method | `// cert is a TCert object. function ConvertToSigned(cert: TChilkatBase): Boolean;` | | `ConvertToSignedPk` | method | `// cert is a TCert object. // privateKey is a TPrivateKey object. function ConvertToSignedPk(cert: TChilkatBase;     privateKey: TChilkatBase): Boolean;` | | `Decrypt` | method | `function Decrypt: Boolean;` | | `Decrypt2` | method | `// cert is a TCert object. // privateKey is a TPrivateKey object. function Decrypt2(cert: TChilkatBase;     privateKey: TChilkatBase): Boolean;` | | `DecryptUsingCert` | method | `// cert is a TCert object. function DecryptUsingCert(cert: TChilkatBase): Boolean;` | | `DecryptUsingPfxFile` | method | `function DecryptUsingPfxFile(const pfxFilePath: string;     const pfxPassword: string): Boolean;` | | `Encrypt` | method | `// cert is a TCert object. function Encrypt(cert: TChilkatBase): Boolean;` | | `EncryptN` | method | `function EncryptN: Boolean;` | | `GetBodyBd` | method | `// binDat is a TBinData object. function GetBodyBd(binDat: TChilkatBase): Boolean;` | | `GetBodyDecoded` | method | `function GetBodyDecoded: string;` | | `GetBodyEncoded` | method | `function GetBodyEncoded: string;` | | `GetDecryptCertInfo` | method | `// certInfo is a TJsonObject object. function GetDecryptCertInfo(certInfo: TChilkatBase): Boolean;` | | `GetEntireBody` | method | `function GetEntireBody: string;` | | `GetEntireHead` | method | `function GetEntireHead: string;` | | `GetHeaderField` | method | `function GetHeaderField(const fieldName: string): string;` | | `GetHeaderFieldAttribute` | method | `function GetHeaderFieldAttribute(const name: string;     const attrName: string): string;` | | `GetHeaderFieldName` | method | `function GetHeaderFieldName(index: Integer): string;` | | `GetHeaderFieldValue` | method | `function GetHeaderFieldValue(index: Integer): string;` | | `GetLastJsonData` | method | `// json is a TJsonObject object. procedure GetLastJsonData(json: TChilkatBase);` | | `GetMime` | method | `function GetMime: string;` | | `GetMimeBd` | method | `// bindat is a TBinData object. function GetMimeBd(bindat: TChilkatBase): Boolean;` | | `GetMimeSb` | method | `// sb is a TStringBuilder object. function GetMimeSb(sb: TChilkatBase): Boolean;` | | `GetSignatureSigningTimeStr` | method | `function GetSignatureSigningTimeStr(index: Integer): string;` | | `GetStructure` | method | `function GetStructure(const fmt: string): string;` | | `GetXml` | method | `function GetXml: string;` | | `HasSignatureSigningTime` | method | `function HasSignatureSigningTime(index: Integer): Boolean;` | | `IsApplicationData` | method | `function IsApplicationData: Boolean;` | | `IsAttachment` | method | `function IsAttachment: Boolean;` | | `IsAudio` | method | `function IsAudio: Boolean;` | | `IsEncrypted` | method | `function IsEncrypted: Boolean;` | | `IsHtml` | method | `function IsHtml: Boolean;` | | `IsImage` | method | `function IsImage: Boolean;` | | `IsMultipart` | method | `function IsMultipart: Boolean;` | | `IsMultipartAlternative` | method | `function IsMultipartAlternative: Boolean;` | | `IsMultipartMixed` | method | `function IsMultipartMixed: Boolean;` | | `IsMultipartRelated` | method | `function IsMultipartRelated: Boolean;` | | `IsPlainText` | method | `function IsPlainText: Boolean;` | | `IsSigned` | method | `function IsSigned: Boolean;` | | `IsText` | method | `function IsText: Boolean;` | | `IsVideo` | method | `function IsVideo: Boolean;` | | `IsXml` | method | `function IsXml: Boolean;` | | `LastDecryptCert` | method | `// cert is a TCert object. function LastDecryptCert(index: Integer;     cert: TChilkatBase): Boolean;` | | `LastSignerCert` | method | `// cert is a TCert object. function LastSignerCert(index: Integer;     cert: TChilkatBase): Boolean;` | | `LoadMime` | method | `function LoadMime(const mimeMsg: string): Boolean;` | | `LoadMimeBd` | method | `// bindat is a TBinData object. function LoadMimeBd(bindat: TChilkatBase): Boolean;` | | `LoadMimeFile` | method | `function LoadMimeFile(const fileName: string): Boolean;` | | `LoadMimeSb` | method | `// sb is a TStringBuilder object. function LoadMimeSb(sb: TChilkatBase): Boolean;` | | `LoadXml` | method | `function LoadXml(const xml: string): Boolean;` | | `LoadXmlFile` | method | `function LoadXmlFile(const fileName: string): Boolean;` | | `NewMessageRfc822` | method | `// mimeObject is a TMime object. function NewMessageRfc822(mimeObject: TChilkatBase): Boolean;` | | `NewMultipartAlternative` | method | `function NewMultipartAlternative: Boolean;` | | `NewMultipartMixed` | method | `function NewMultipartMixed: Boolean;` | | `NewMultipartRelated` | method | `function NewMultipartRelated: Boolean;` | | `PartAt` | method | `// subPart is a TMime object. function PartAt(index: Integer;     subPart: TChilkatBase): Boolean;` | | `PartsToFiles` | method | `// st is a TStringTable object. function PartsToFiles(const path: string;     st: TChilkatBase): Boolean;` | | `RemoveHeaderField` | method | `procedure RemoveHeaderField(const fieldName: string;     bAllOccurrences: Boolean);` | | `RemovePart` | method | `function RemovePart(index: Integer): Boolean;` | | `SaveBody` | method | `function SaveBody(const filename: string): Boolean;` | | `SaveMime` | method | `function SaveMime(const filename: string): Boolean;` | | `SaveXml` | method | `function SaveXml(const filename: string): Boolean;` | | `SetBody` | method | `procedure SetBody(const str: string);` | | `SetBodyBd` | method | `// bd is a TBinData object. function SetBodyBd(bd: TChilkatBase): Boolean;` | | `SetBodyFromEncoded` | method | `function SetBodyFromEncoded(const encoding: string;     const str: string): Boolean;` | | `SetBodyFromFile` | method | `function SetBodyFromFile(const fileName: string): Boolean;` | | `SetBodyFromHtml` | method | `function SetBodyFromHtml(const str: string): Boolean;` | | `SetBodyFromPlainText` | method | `function SetBodyFromPlainText(const str: string): Boolean;` | | `SetBodyFromXml` | method | `function SetBodyFromXml(const str: string): Boolean;` | | `SetHeaderField` | method | `function SetHeaderField(const name: string;     const value: string): Boolean;` | | `SetVerifyCert` | method | `// cert is a TCert object. function SetVerifyCert(cert: TChilkatBase): Boolean;` | | `UnwrapSecurity` | method | `function UnwrapSecurity: Boolean;` | | `UrlEncodeBody` | method | `procedure UrlEncodeBody(const charset: string);` | | `UseCertVault` | method | `// vault is a TXmlCertVault object. function UseCertVault(vault: TChilkatBase): Boolean;` | | `Verify` | method | `function Verify: Boolean;` | ## Properties ### Mime.Boundary `Chilkat 11.7.0 · pascal · Mime · Boundary · property · read/write` ```pascal property Boundary: string read GetBoundary write SetBoundary; ``` Gets or sets the raw boundary token used by a multipart MIME entity. Do not include surrounding quotation marks. ``` Content-Type: multipart/mixed; boundary="example-boundary" ``` For this example, `Boundary` is `example-boundary`. Chilkat automatically quotes the parameter when the token contains characters such as spaces or semicolons. **Normally automatic.** Methods such as `NewMultipartMixed`, `NewMultipartAlternative`, and `NewMultipartRelated` generate a nonempty boundary. **Caller-supplied boundaries are not validated.** Chilkat does not detect collisions with body text. An empty value is permitted but produces invalid multipart delimiters, and supplying quotation marks as part of the property value causes those quotation marks to become part of the boundary. The property can also be set on a nonmultipart entity, where it is simply added as a `Content-Type` parameter. ### Mime.Charset `Chilkat 11.7.0 · pascal · Mime · Charset · property · read/write` ```pascal property Charset: string read GetCharset write SetCharset; ``` Gets or sets the `charset` parameter of the `Content-Type` header field. ``` Content-Type: text/plain; charset=utf-8 ``` Changing this property preserves the media type and other parameters. Setting it when no `Content-Type` exists creates a `Content-Type` field, although the media type remains empty until `ContentType` is set. **Charset versus transfer encoding.** The charset identifies how text characters are represented as bytes. `Encoding` controls the MIME transport representation of those bytes. **Empty-string behavior.** Setting `Charset` to an empty string does not remove the parameter. It selects the platform default ANSI charset; on Windows this is typically `windows-1252`. ### Mime.CmsOptions `Chilkat 11.7.0 · pascal · Mime · CmsOptions · property · read/write · since 9.5.0.78` ```pascal property CmsOptions: string read GetCmsOptions write SetCmsOptions; ``` Gets or sets a JSON string containing advanced CMS/PKCS #7 signing and validation options. The default is an empty string, which selects normal behavior. A valid empty JSON object may also be supplied as `{}`. Unknown JSON members are retained but ignored. Malformed JSON is normalized to `{}`. This property is intended for specialized interoperability requirements; applications should leave it empty unless a documented option is specifically needed. ### Mime.ContentType `Chilkat 11.7.0 · pascal · Mime · ContentType · property · read/write` ```pascal property ContentType: string read GetContentType write SetContentType; ``` Gets or sets the MIME media type of the current part, excluding all parameters. Supply a value such as `text/plain`, `text/html`, `application/pdf`, or `multipart/mixed`; do not include `charset`, `boundary`, or other parameters in this property. Changing the media type preserves the existing `charset` and unrecognized parameters, but may remove parameters that are specific to the previous media type, such as `format=flowed`. Setting an empty string leaves an empty media type and can therefore produce an invalid-looking header if other parameters remain. **Classification methods use this value.** Methods such as `IsText`, `IsImage`, and `IsMultipart` classify the media type stored here. Parameters must be set through their dedicated properties or header attributes, not appended to `ContentType`. ### Mime.CurrentDateTime `Chilkat 11.7.0 · pascal · Mime · CurrentDateTime · property · read-only` ```pascal property CurrentDateTime: string read GetCurrentDateTime; ``` Returns the current local date and time formatted as an Internet message date, including the numeric UTC offset. For example: ``` Fri, 21 Nov 1997 09:55:06 -0600 ``` ### Mime.Disposition `Chilkat 11.7.0 · pascal · Mime · Disposition · property · read/write` ```pascal property Disposition: string read GetDisposition write SetDisposition; ``` Gets or sets the disposition value from the `Content-Disposition` header field, excluding parameters such as `filename`. ``` Content-Disposition: attachment; filename="report.pdf" ``` Changing this property preserves an existing `filename` parameter. Typical values are `attachment` and `inline`. ### Mime.Encoding `Chilkat 11.7.0 · pascal · Mime · Encoding · property · read/write` ```pascal property Encoding: string read GetEncoding write SetEncoding; ``` Gets or sets the value of the `Content-Transfer-Encoding` header field for the current part. Common values include `base64`, `quoted-printable`, `7bit`, `8bit`, and `binary`. **Transfer encoding is not compression.** It determines how the body bytes are represented in serialized MIME. `GetBodyEncoded` returns the transfer-encoded form, while `GetBodyBd`, `GetBodyBinary`, and `SaveBody` return or save decoded bytes. ### Mime.Filename `Chilkat 11.7.0 · pascal · Mime · Filename · property · read/write` ```pascal property Filename: string read GetFilename write SetFilename; ``` Gets or sets the `filename` parameter of the `Content-Disposition` header field. The value is a receiver-facing filename, not a local filesystem path. Changing this property preserves the disposition value but removes other `Content-Disposition` parameters such as `size`. Setting an empty string removes the `filename` parameter. **International filenames.** When setting a non-ASCII filename, Chilkat emits an RFC 2047 encoded-word in `filename=`. When reading a header containing both `filename=` and `filename*=`, this property returns `filename=`. Use `GetHeaderFieldAttribute` to retrieve the raw `filename*` value. ### Mime.Micalg `Chilkat 11.7.0 · pascal · Mime · Micalg · property · read/write` ```pascal property Micalg: string read GetMicalg write SetMicalg; ``` Gets or sets the `micalg` parameter of a `multipart/signed` `Content-Type` header field. ``` Content-Type: multipart/signed; protocol="application/pkcs7-signature"; micalg=sha-256; boundary="example-boundary" ``` The parameter advertises the message-digest algorithm used by the detached signature. **SigningHashAlg is authoritative.** When a detached signature is created, `SigningHashAlg` selects the digest and Chilkat replaces any conflicting `Micalg` value with the corresponding MIME token, such as `sha-1`, `sha-256`, `sha-384`, or `sha-512`. Setting `Micalg` alone does not select the cryptographic digest. ### Mime.Name `Chilkat 11.7.0 · pascal · Mime · Name · property · read/write` ```pascal property Name: string read GetName write SetName; ``` Gets or sets the `name` parameter of the `Content-Type` header field. For attachments, `Filename` is generally the primary receiver-facing name. Setting a non-ASCII value causes Chilkat to emit an RFC 2047 encoded-word in the `name=` parameter. Setting this property when no media type exists creates a `Content-Type` field with an empty media type. ### Mime.NumDecryptCerts `Chilkat 11.7.0 · pascal · Mime · NumDecryptCerts · property · read-only · since 11.0.0` ```pascal property NumDecryptCerts: Integer read GetNumDecryptCerts; ``` Returns the number of recipient or decryption certificates currently recorded by the most recent S/MIME encryption, decryption, or security-unwrapping operation. A new object returns `0`. A successful single-recipient `Encrypt` records `1`, and successful decryption records the certificate whose private key was used. Use `LastDecryptCert` with a zero-based index to retrieve a recorded certificate. This is a result count; it is not the number of PFX sources or decryption certificates configured on the object. ### Mime.NumHeaderFields `Chilkat 11.7.0 · pascal · Mime · NumHeaderFields · property · read-only` ```pascal property NumHeaderFields: Integer read GetNumHeaderFields; ``` Returns the number of header-field occurrences in the current part. Duplicate names count separately and retain their order. Valid indexes range from `0` through `NumHeaderFields - 1` for use with `GetHeaderFieldName` and `GetHeaderFieldValue`. During MIME parsing, duplicate ordinary fields are retained. Duplicate `Content-Type` fields are collapsed, with the last value taking effect. ### Mime.NumParts `Chilkat 11.7.0 · pascal · Mime · NumParts · property · read-only` ```pascal property NumParts: Integer read GetNumParts; ``` Returns the number of direct child parts. It does not include deeper descendants. Iterate from `0` through `NumParts - 1` and call `PartAt` to traverse the tree. The object returned by `PartAt` provides live access to the stored child. Modifying that returned object modifies the parent MIME tree. ### Mime.NumSignerCerts `Chilkat 11.7.0 · pascal · Mime · NumSignerCerts · property · read-only` ```pascal property NumSignerCerts: Integer read GetNumSignerCerts; ``` Returns the number of signer certificates currently recorded by the most recent S/MIME signing, signature-verification, or security-unwrapping operation. A new object returns `0`. A single-certificate signing method records `1`; `Verify` and `UnwrapSecurity` replace the count with the signer results from that operation. A failed call to `Verify` clears the signer results and sets this property to `0`. Use `LastSignerCert` with a zero-based index to retrieve a recorded signer certificate. ### Mime.OaepHash `Chilkat 11.7.0 · pascal · Mime · OaepHash · property · read/write · since 9.5.0.67` ```pascal property OaepHash: string read GetOaepHash write SetOaepHash; ``` Gets or sets the hash algorithm used by RSAES-OAEP when encrypting the CMS content-encryption key. Supported values are `sha1`, `sha256`, `sha384`, and `sha512`. The default is `sha256`. An empty or unrecognized value leaves the current valid setting unchanged. This property is used only when `OaepPadding` is `True`. It is independent of `OaepMgfHash`; for example, OAEP may use SHA-256 while MGF1 uses SHA-1. ### Mime.OaepMgfHash `Chilkat 11.7.0 · pascal · Mime · OaepMgfHash · property · read/write · since 9.5.0.71` ```pascal property OaepMgfHash: string read GetOaepMgfHash write SetOaepMgfHash; ``` Gets or sets the hash algorithm used by the MGF1 mask generation function within RSAES-OAEP. Supported values are `sha1`, `sha256`, `sha384`, and `sha512`. The default is `sha256`. An empty or unrecognized value leaves the current valid setting unchanged. This property is used only when `OaepPadding` is `True` and is independent of `OaepHash`. ### Mime.OaepPadding `Chilkat 11.7.0 · pascal · Mime · OaepPadding · property · read/write · since 9.5.0.67` ```pascal property OaepPadding: Boolean read GetOaepPadding write SetOaepPadding; ``` Selects the RSA key-transport padding used when creating encrypted MIME. The default is `False`, which uses RSAES-PKCS1-v1_5. Set to `True` to use RSAES-OAEP. **Scope.** This setting protects the symmetric content-encryption key for an RSA recipient. It does not change the symmetric content algorithm selected by `Pkcs7CryptAlg`. ### Mime.Pkcs7CryptAlg `Chilkat 11.7.0 · pascal · Mime · Pkcs7CryptAlg · property · read/write` ```pascal property Pkcs7CryptAlg: string read GetPkcs7CryptAlg write SetPkcs7CryptAlg; ``` Gets or sets the symmetric content-encryption algorithm used when creating CMS/PKCS #7 encrypted MIME. Supported input values are `aes`, `aes-gcm`, `des`, `3des`, and `rc2`. The default is `aes`. The `aes-gcm` option was added in version 10.0.0. The getter returns normalized names: after setting `aes-gcm` it returns `aes`, and after setting `3des` it returns `des`. The generated CMS data nevertheless uses AES-GCM or 3DES-CBC respectively. **Hybrid encryption.** S/MIME encrypts the MIME content with a symmetric content-encryption key. The recipient certificate then protects that content-encryption key. This property selects the symmetric algorithm; `Pkcs7KeyLength` selects its key length. ### Mime.Pkcs7KeyLength `Chilkat 11.7.0 · pascal · Mime · Pkcs7KeyLength · property · read/write` ```pascal property Pkcs7KeyLength: Integer read GetPkcs7KeyLength write SetPkcs7KeyLength; ``` Gets or sets the content-encryption key length, in bits, used when creating CMS/PKCS #7 encrypted MIME. The default is `128`. Because this property may be set before `Pkcs7CryptAlg`, the setter accepts the union of key lengths that can be valid for any supported symmetric algorithm: `40`, `56`, `64`, `128`, `192`, and `256`. A value outside this set is rejected and the previous value is retained. | Algorithm | Normal key lengths | | :--- | :--- | | `aes` or `aes-gcm` | `128`, `192`, or `256` | | `3des` | `192` | | `des` | `40` | | `rc2` | `40`, `56`, `64`, or `128` | **Set both properties before encrypting.** The property setter rejects only lengths that cannot be valid for any supported algorithm. Applications should select the algorithm and its appropriate key length before calling `Encrypt` or `EncryptN`. ### Mime.Protocol `Chilkat 11.7.0 · pascal · Mime · Protocol · property · read/write` ```pascal property Protocol: string read GetProtocol write SetProtocol; ``` Gets or sets the `protocol` parameter of the `Content-Type` header field. This parameter is commonly used by `multipart/signed` to identify the media type of the detached signature part. ``` Content-Type: multipart/signed; protocol="application/pkcs7-signature"; micalg=sha-256; boundary="example-boundary" ``` For this example, `Protocol` is `application/pkcs7-signature`. ### Mime.SigningAlg `Chilkat 11.7.0 · pascal · Mime · SigningAlg · property · read/write · since 9.5.0.67` ```pascal property SigningAlg: string read GetSigningAlg write SetSigningAlg; ``` Gets or sets the RSA signature scheme used when creating CMS/PKCS #7 signed MIME. The default and normalized PKCS #1 v1.5 value is `PKCS1-V1_5`. Set the property to `RSASSA-PSS` or `pss` to use RSASSA-PSS; the getter returns `RSASSA-PSS`. An empty or unrecognized value selects `PKCS1-V1_5`. This setting applies only when the signing private key is RSA. It does not select the signature scheme for EC or DSA keys. The property controls signature creation and is not updated during verification; use `GetLastJsonData` to inspect a verified signature. ### Mime.SigningHashAlg `Chilkat 11.7.0 · pascal · Mime · SigningHashAlg · property · read/write` ```pascal property SigningHashAlg: string read GetSigningHashAlg write SetSigningHashAlg; ``` Gets or sets the message-digest algorithm used when creating CMS/PKCS #7 signatures. The default is `sha256`. Supported values are `sha1`, `sha256`, `sha384`, `sha512`, `md5`, and `md2`. Names are case-insensitive and are returned in lowercase. An empty or unrecognized value selects `sha1`. This property controls signature creation only and is not changed when a signature is verified. After verification, call `GetLastJsonData` to inspect the digest algorithm found in the signed data. **Security guidance.** Use a SHA-2 algorithm such as `sha256` unless interoperability with a legacy system requires otherwise. MD2, MD5, and SHA-1 are retained for compatibility with older signed messages. Because invalid input falls back to SHA-1, applications should set this property to a known supported value. ### Mime.UncommonOptions `Chilkat 11.7.0 · pascal · Mime · UncommonOptions · property · read/write · since 9.5.0.89` ```pascal property UncommonOptions: string read GetUncommonOptions write SetUncommonOptions; ``` Gets or sets a semicolon-delimited or implementation-specific option string used for uncommon compatibility requirements. The default is the empty string, and normal applications should leave it empty. Options placed here may be version-specific and should be used only when directed by Chilkat documentation or support. ### Mime.UnwrapExtras `Chilkat 11.7.0 · pascal · Mime · UnwrapExtras · property · read/write` ```pascal property UnwrapExtras: Boolean read GetUnwrapExtras write SetUnwrapExtras; ``` Controls whether `UnwrapSecurity` adds informative header fields describing the security layers removed. The default is `True`. | Header | Example value | | :--- | :--- | | `X-NumPartsSigned` | `1` | | `X-SignaturesValid` | `yes` | | `X-NumPartsEncrypted` | `1` | | `X-Decrypted` | `yes` | Set to `False` when the application requires the unwrapped MIME without these additional status headers. ### Mime.UseMmDescription `Chilkat 11.7.0 · pascal · Mime · UseMmDescription · property · read/write` ```pascal property UseMmDescription: Boolean read GetUseMmDescription write SetUseMmDescription; ``` Controls whether Chilkat uses the conventional multipart preamble text `This is a multi-part message in MIME format.` when serializing a multipart entity. The default is `False`. The preamble is meaningful only when the multipart has content and is ignored by MIME-aware readers. ### Mime.UseXPkcs7 `Chilkat 11.7.0 · pascal · Mime · UseXPkcs7 · property · read/write` ```pascal property UseXPkcs7: Boolean read GetUseXPkcs7 write SetUseXPkcs7; ``` Controls whether newly created S/MIME media types use the historical `x-pkcs7` names. | Value | Generated media types | | :--- | :--- | | `True` (default) | `application/x-pkcs7-mime` and `application/x-pkcs7-signature` | | `False` | `application/pkcs7-mime` and `application/pkcs7-signature` | For detached signatures, the selected signature media type is used both for the outer `protocol` parameter and for the signature part. For opaque signed or encrypted MIME, it controls the `application/...pkcs7-mime` content type. **Interoperability.** The `x-` forms are widely encountered in existing S/MIME messages. Chilkat recognizes both naming forms. ## Methods ### Mime.AddContentLength `Chilkat 11.7.0 · pascal · Mime · AddContentLength · method` ```pascal procedure AddContentLength; ``` Computes the byte length of the current entity's serialized MIME body and adds or updates its `Content-Length` header. The count is based on the transfer-encoded serialized body, not the decoded payload. For a multipart entity, the count includes boundary delimiter lines, child headers, child bodies, and the closing boundary. Only the current entity's header is updated; child parts do not receive `Content-Length` fields. Repeated calls recompute the value and leave a single header occurrence. ### Mime.AddDecryptCert `Chilkat 11.7.0 · pascal · Mime · AddDecryptCert · method · since 9.5.0.40` ```pascal // cert is a TCert object. function AddDecryptCert(cert: TChilkatBase): Boolean; ``` Adds `cert` to the internal collection of certificates available for S/MIME decryption. The certificate must have access to its corresponding private key. Call this method once for each candidate certificate. The collection is searched by `Decrypt` and `UnwrapSecurity`. Other ways to provide decryption credentials include `AddPfxSourceFile`, `AddPfxSourceBd`, and `UseCertVault`. Returns True for success, False for failure. ### Mime.AddDetachedSignature `Chilkat 11.7.0 · pascal · Mime · AddDetachedSignature · method` ```pascal // cert is a TCert object. function AddDetachedSignature(cert: TChilkatBase): Boolean; ``` Creates an S/MIME detached signature using `cert`. The certificate itself must have access to its private key. On success, the current object becomes a `multipart/signed` entity with two direct children: | Part | Contents | | :--- | :--- | | First | The original MIME entity being signed. | | Second | The CMS/PKCS #7 signature data, normally named `smime.p7s`. | `SigningHashAlg` selects the digest and generated `micalg` parameter. For RSA keys, `SigningAlg` selects PKCS #1 v1.5 or RSASSA-PSS. `UseXPkcs7` selects the signature media-type spelling. **Private-key requirement.** Adding a matching PFX source does not supply a missing signing key for a public-only `Cert`. Load the private key into `cert` or use `AddDetachedSignaturePk`. **Signing an already signed MIME.** Calling this method again creates a new outer `multipart/signed` layer. It does not add another signer to the existing CMS signer-information set. Returns True for success, False for failure. ### Mime.AddDetachedSignature2 `Chilkat 11.7.0 · pascal · Mime · AddDetachedSignature2 · method` ```pascal // cert is a TCert object. function AddDetachedSignature2(cert: TChilkatBase;     transferHeaderFields: Boolean): Boolean; ``` Creates the same detached `multipart/signed` structure as `AddDetachedSignature`. `cert` is the signing certificate and must have access to its private key. | `transferHeaderFields` | Header placement | | :--- | :--- | | `False` | Existing message header fields, such as `Subject` and `From`, remain on the first signed content part. The new outer multipart has no copies of those fields. | | `True` | Existing message header fields are moved to the new outer `multipart/signed` entity and removed from the first content part. | Returns True for success, False for failure. ### Mime.AddDetachedSignaturePk `Chilkat 11.7.0 · pascal · Mime · AddDetachedSignaturePk · method` ```pascal // cert is a TCert object. // privateKey is a TPrivateKey object. function AddDetachedSignaturePk(cert: TChilkatBase;     privateKey: TChilkatBase): Boolean; ``` Creates a detached S/MIME signature using `cert` as the signer certificate and `privateKey` as its associated private key. Use this method when the certificate and private key are supplied separately. On success, the current object becomes the same two-part `multipart/signed` structure described by `AddDetachedSignature`. `SigningHashAlg`, `SigningAlg`, and `UseXPkcs7` control the generated signature. Returns True for success, False for failure. ### Mime.AddDetachedSignaturePk2 `Chilkat 11.7.0 · pascal · Mime · AddDetachedSignaturePk2 · method` ```pascal // cert is a TCert object. // privateKey is a TPrivateKey object. function AddDetachedSignaturePk2(cert: TChilkatBase;     privateKey: TChilkatBase;     transferHeaderFields: Boolean): Boolean; ``` Creates a detached S/MIME signature using the certificate in `cert` and the corresponding private key in `privateKey`. `transferHeaderFields` controls placement of the existing message header fields: | `transferHeaderFields` | Header placement | | :--- | :--- | | `False` | Headers remain on the first signed content part. | | `True` | Headers are moved to the new outer `multipart/signed` entity and removed from the first content part. | This is the separate-private-key counterpart of `AddDetachedSignature2`. Returns True for success, False for failure. ### Mime.AddEncryptCert `Chilkat 11.7.0 · pascal · Mime · AddEncryptCert · method` ```pascal // cert is a TCert object. function AddEncryptCert(cert: TChilkatBase): Boolean; ``` Adds `cert` to the internal recipient-certificate list used by `EncryptN`. Call this method once for each intended recipient. Encryption uses the public key in each certificate, so recipient private keys are not required at encryption time. Call `ClearEncryptCerts` to empty the list. Returns True for success, False for failure. ### Mime.AddHeaderField `Chilkat 11.7.0 · pascal · Mime · AddHeaderField · method` ```pascal function AddHeaderField(const name: string;     const value: string): Boolean; ``` Appends a new header field named by `name` with the value in `value`. Existing fields having the same case-insensitive name are preserved. An empty `value` creates a legal empty-valued field. Chilkat converts spaces in a header name to hyphens, removes embedded CR and LF characters from the value to prevent header injection, and folds long values when serializing. **Replacing versus appending.** Use `SetHeaderField` to remove all existing occurrences and set one replacement value. Returns True for success, False for failure. ### Mime.AddPfxSourceBd `Chilkat 11.7.0 · pascal · Mime · AddPfxSourceBd · method · since 11.0.0` ```pascal // bd is a TBinData object. function AddPfxSourceBd(bd: TChilkatBase;     const password: string): Boolean; ``` Adds the PKCS #12/PFX bytes in `bd` to the internal collection of credential sources used by later S/MIME decryption operations. `password` is the password protecting the PFX data. Call the method once for each PFX source that should be searched. The source remains configured across subsequent `LoadMime` calls and repeated decryptions. Chilkat continues searching after a PFX that does not contain the required recipient key. **Not a signing-key fallback.** Adding a PFX source does not make a public-only certificate usable by the signing methods. The signing certificate itself must have its private key, or the private key must be supplied explicitly by a method whose name ends in `Pk`. Returns True for success, False for failure. ### Mime.AddPfxSourceFile `Chilkat 11.7.0 · pascal · Mime · AddPfxSourceFile · method` ```pascal function AddPfxSourceFile(const pfxFilePath: string;     const password: string): Boolean; ``` Adds the PFX/P12 file at the local filesystem path in `pfxFilePath` to the internal collection of credential sources used by later S/MIME decryption operations. `password` is the password protecting the file. Call the method once for each PFX source that should be searched. The source remains configured across subsequent `LoadMime` calls and repeated decryptions. Chilkat continues searching after a PFX that does not contain the required recipient key. **Not a signing-key fallback.** Adding a PFX source does not make a public-only certificate usable by the signing methods. The signing certificate itself must have its private key, or the private key must be supplied explicitly by a method whose name ends in `Pk`. Returns True for success, False for failure. ### Mime.AppendPart `Chilkat 11.7.0 · pascal · Mime · AppendPart · method` ```pascal // mime is a TMime object. function AppendPart(mime: TChilkatBase): Boolean; ``` Appends a copy of `mime` as the last direct child. Chilkat does not retain a reference to `mime`, so later changes to `mime` do not affect the appended part. The same source object may be appended more than once. If the current object is not multipart, it is converted to `multipart/mixed`. The complete original entity, including its existing headers and body, becomes part 0; the copy of `mime` becomes part 1. The new outer entity contains its generated multipart `Content-Type`. **Editing an appended child.** Retrieve it with `PartAt`. The object returned by `PartAt` is a live child, unlike the copied input to this method. Returns True for success, False for failure. ### Mime.AppendPartFromFile `Chilkat 11.7.0 · pascal · Mime · AppendPartFromFile · method` ```pascal function AppendPartFromFile(const filename: string): Boolean; ``` Reads the local file at `filename`, creates an attachment part, and appends it. Filename-extension matching is case-insensitive. | File kind | Generated headers | | :--- | :--- | | `.txt` | `text/plain; charset=windows-1252; format=flowed`, `7bit`, attachment filename and name | | Known binary type, such as `.PNG` | Inferred media type such as `image/png`, `base64`, attachment filename and name | | Unknown extension | `application/octet-stream`, `base64`, attachment filename and name | If the current object is not multipart, the same conversion described by `AppendPart` occurs. Calling this method on a new empty object therefore creates an empty part 0 and the file attachment as part 1. Returns True for success, False for failure. ### Mime.AsnBodyToXml `Chilkat 11.7.0 · pascal · Mime · AsnBodyToXml · method` ```pascal function AsnBodyToXml: string; ``` Parses the current part's decoded body as ASN.1 DER and returns an XML representation of the ASN.1 structure. This is primarily useful for inspecting CMS/PKCS #7 bodies such as `application/pkcs7-mime` or `application/x-pkcs7-mime`. ``` Content-Type: application/pkcs7-mime; smime-type=signed-data Content-Transfer-Encoding: base64 MII... ``` **Diagnostic conversion.** The returned XML exposes ASN.1 tags, object identifiers, and values for inspection. It is not the MIME-to-XML representation returned by `GetXml`. Returns True for success, False for failure. ### Mime.ClearEncryptCerts `Chilkat 11.7.0 · pascal · Mime · ClearEncryptCerts · method` ```pascal procedure ClearEncryptCerts; ``` Clears the internal recipient-certificate list populated by `AddEncryptCert`. A subsequent call to `EncryptN` requires certificates to be added again. ### Mime.ContainsEncryptedParts `Chilkat 11.7.0 · pascal · Mime · ContainsEncryptedParts · method` ```pascal function ContainsEncryptedParts: Boolean; ``` Returns `True` if the currently visible MIME tree contains a CMS/PKCS #7 encrypted entity. Both `application/pkcs7-mime` and `application/x-pkcs7-mime` forms are recognized. **Encrypted layers hide their contents.** This method examines the MIME structure as it currently exists. It cannot report signed or encrypted entities inside ciphertext until the enclosing encrypted layer is successfully removed. ### Mime.ContainsSignedParts `Chilkat 11.7.0 · pascal · Mime · ContainsSignedParts · method` ```pascal function ContainsSignedParts: Boolean; ``` Returns `True` if the currently visible MIME tree contains a complete detached or opaque CMS/PKCS #7 signed entity. A standalone `application/pkcs7-signature` or `application/x-pkcs7-signature` leaf part is not by itself classified as a signed message. **Encrypted layers hide their contents.** A signature nested inside encrypted data is not visible until the encrypted layer is removed. After a signature is successfully verified and unwrapped, this method returns `False` because the signed wrapper no longer exists. ### Mime.Convert8Bit `Chilkat 11.7.0 · pascal · Mime · Convert8Bit · method` ```pascal procedure Convert8Bit; ``` Recursively converts every part whose `Content-Transfer-Encoding` is `8bit` or `binary` to `base64`. Both the child object's `Encoding` property and the serialized header are updated. Parts using `7bit` or another encoding are unchanged. ### Mime.ConvertToMultipartAlt `Chilkat 11.7.0 · pascal · Mime · ConvertToMultipartAlt · method` ```pascal function ConvertToMultipartAlt: Boolean; ``` Wraps the current entity in a new outer `multipart/alternative` entity. The original entity becomes the first and initially only child. The new outer entity retains message-level and custom headers such as `MIME-Version`, `Date`, `Subject`, `From`, `To`, `Content-ID`, `Content-Location`, and custom fields. The original `Content-Type`, `Content-Transfer-Encoding`, `Content-Disposition`, and body move to the first child. An existing `charset` parameter is retained on the new multipart `Content-Type`. Calling the method again wraps the existing multipart in another multipart layer; the operation is not idempotent. **Alternative ordering.** Additional representations can be appended with `AppendPart`. Conventionally, alternatives are ordered from least rich to most rich, such as `text/plain` followed by `text/html`. Returns True for success, False for failure. ### Mime.ConvertToMultipartMixed `Chilkat 11.7.0 · pascal · Mime · ConvertToMultipartMixed · method` ```pascal function ConvertToMultipartMixed: Boolean; ``` Wraps the current entity in a new outer `multipart/mixed` entity. The original entity becomes the first and initially only child. The new outer entity retains message-level and custom headers such as `MIME-Version`, `Date`, `Subject`, `From`, `To`, `Content-ID`, `Content-Location`, and custom fields. The original `Content-Type`, `Content-Transfer-Encoding`, `Content-Disposition`, and body move to the first child. An existing `charset` parameter is retained on the new multipart `Content-Type`. Calling the method again wraps the existing multipart in another multipart layer; the operation is not idempotent. Returns True for success, False for failure. ### Mime.ConvertToSigned `Chilkat 11.7.0 · pascal · Mime · ConvertToSigned · method` ```pascal // cert is a TCert object. function ConvertToSigned(cert: TChilkatBase): Boolean; ``` Creates an opaque (attached) S/MIME signature using `cert`. The certificate itself must have access to its private key. On success, the current MIME entity is replaced by CMS/PKCS #7 `signed-data` containing both the original MIME bytes and the signature. The result has no MIME child parts, uses Base64 content-transfer encoding, and has an `application/x-pkcs7-mime` or `application/pkcs7-mime` content type according to `UseXPkcs7`. `SigningHashAlg` and, for RSA keys, `SigningAlg` select the signing algorithms. This differs from `AddDetachedSignature`, which creates a visible `multipart/signed` wrapper with a separate signature part. Returns True for success, False for failure. ### Mime.ConvertToSignedPk `Chilkat 11.7.0 · pascal · Mime · ConvertToSignedPk · method` ```pascal // cert is a TCert object. // privateKey is a TPrivateKey object. function ConvertToSignedPk(cert: TChilkatBase;     privateKey: TChilkatBase): Boolean; ``` Creates an opaque (attached) S/MIME signature using `cert` as the signer certificate and `privateKey` as its associated private key. Use this method when the certificate and private key are supplied separately. The resulting CMS/PKCS #7 `signed-data` contains the original MIME entity and its signature, has no MIME child parts, and uses Base64 content-transfer encoding. For a detached `multipart/signed` result, use `AddDetachedSignaturePk`. Returns True for success, False for failure. ### Mime.Decrypt `Chilkat 11.7.0 · pascal · Mime · Decrypt · method` ```pascal function Decrypt: Boolean; ``` Decrypts the current CMS/PKCS #7 encrypted MIME entity and replaces it with the recovered MIME content. Chilkat identifies the intended recipient from the CMS recipient information and searches configured credential sources for the matching certificate and private key. | Source | How it is supplied | | :--- | :--- | | Explicit certificate | `AddDecryptCert` or `DecryptUsingCert` | | PFX/P12 | `AddPfxSourceFile`, `AddPfxSourceBd`, or a `DecryptUsingPfx...` method | | Certificate vault | `UseCertVault` | | Platform certificate store | Windows certificate stores and the macOS Keychain are searched automatically where supported | On success, `NumDecryptCerts` and `LastDecryptCert` identify the certificate used, and `GetLastJsonData` reports the content-encryption algorithm and key size. On failure, the encrypted MIME remains unchanged. **Serialization after decryption.** The recovered MIME content is restored semantically, but its generated serialization is not guaranteed to be byte-for-byte identical to the bytes that existed before encryption. Returns True for success, False for failure. ### Mime.Decrypt2 `Chilkat 11.7.0 · pascal · Mime · Decrypt2 · method` ```pascal // cert is a TCert object. // privateKey is a TPrivateKey object. function Decrypt2(cert: TChilkatBase;     privateKey: TChilkatBase): Boolean; ``` Decrypts the current CMS/PKCS #7 encrypted MIME entity using the certificate in `cert` and its associated private key in `privateKey`. On success, the encrypted wrapper is replaced by the recovered MIME content, the decryption certificate is available through `LastDecryptCert`, and operation details are available through `GetLastJsonData`. On failure, the encrypted MIME remains unchanged. Use this method when the certificate and private key are stored separately. Use `Decrypt` when Chilkat should locate the credential from configured sources. Returns True for success, False for failure. ### Mime.DecryptUsingCert `Chilkat 11.7.0 · pascal · Mime · DecryptUsingCert · method · since 9.5.0.40` ```pascal // cert is a TCert object. function DecryptUsingCert(cert: TChilkatBase): Boolean; ``` Decrypts the current CMS/PKCS #7 encrypted MIME entity using `cert`. The certificate must have access to its corresponding private key; a public-only certificate is insufficient. On success, the encrypted wrapper is replaced by the recovered MIME content and `cert` is recorded in the decryption results. On failure, the encrypted MIME remains unchanged. Returns True for success, False for failure. ### Mime.DecryptUsingPfxFile `Chilkat 11.7.0 · pascal · Mime · DecryptUsingPfxFile · method` ```pascal function DecryptUsingPfxFile(const pfxFilePath: string;     const pfxPassword: string): Boolean; ``` Decrypts the current CMS/PKCS #7 encrypted MIME entity using certificates and private keys from the PFX/P12 file at the local filesystem path in `pfxFilePath`. `pfxPassword` is the password protecting the file. On success, the encrypted wrapper is replaced by the recovered MIME content and the matching certificate is available through `LastDecryptCert`. `GetLastJsonData` may include both CMS decryption details and information produced while reading the PFX. On failure, the encrypted MIME remains unchanged. Returns True for success, False for failure. ### Mime.Encrypt `Chilkat 11.7.0 · pascal · Mime · Encrypt · method` ```pascal // cert is a TCert object. function Encrypt(cert: TChilkatBase): Boolean; ``` Encrypts the current MIME entity for the recipient certificate in `cert` and replaces it with CMS/PKCS #7 encrypted S/MIME. `cert` must be RSA-based. Only the recipient's public key is needed to encrypt; the matching private key is required later to decrypt. The default content encryption is AES-128-CBC. `Pkcs7CryptAlg` and `Pkcs7KeyLength` select the symmetric algorithm and key length. By default, RSAES-PKCS1-v1_5 transports the content-encryption key; set `OaepPadding` to `True` to use RSAES-OAEP, with `OaepHash` and `OaepMgfHash` controlling its parameters. The generated MIME uses Base64 transfer encoding, the filename `smime.p7m`, and an `application/x-pkcs7-mime` or `application/pkcs7-mime` content type according to `UseXPkcs7`. After encryption, `GetDecryptCertInfo` can report the recipient identifiers stored in the CMS data. If encryption fails, the original MIME remains unchanged. Returns True for success, False for failure. ### Mime.EncryptN `Chilkat 11.7.0 · pascal · Mime · EncryptN · method` ```pascal function EncryptN: Boolean; ``` Encrypts the current MIME entity for every certificate previously added with `AddEncryptCert`. Each recipient receives independently protected access to the same encrypted content. Add one certificate per intended recipient, call this method, and use `ClearEncryptCerts` before preparing a different recipient set. Returns True for success, False for failure. ### Mime.GetBodyBd `Chilkat 11.7.0 · pascal · Mime · GetBodyBd · method · since 9.5.0.67` ```pascal // binDat is a TBinData object. function GetBodyBd(binDat: TChilkatBase): Boolean; ``` Replaces the contents of `binDat` with the decoded body bytes of the current part. Existing bytes in `binDat` are discarded. Base64 and quoted-printable are decoded. MIME headers, multipart boundaries, and child parts are not included. Returns True for success, False for failure. ### Mime.GetBodyDecoded `Chilkat 11.7.0 · pascal · Mime · GetBodyDecoded · method` ```pascal function GetBodyDecoded: string; ``` Returns the decoded body as text. Chilkat first decodes the `Content-Transfer-Encoding` and then interprets text according to the declared charset. **Use a byte-oriented getter for binary content.** A string result cannot reliably represent arbitrary binary bytes or embedded NUL bytes. Use `GetBodyBd` or `GetBodyBinary` for binary payloads. Returns True for success, False for failure. ### Mime.GetBodyEncoded `Chilkat 11.7.0 · pascal · Mime · GetBodyEncoded · method` ```pascal function GetBodyEncoded: string; ``` Returns the current part's transfer-encoded body text without decoding Base64 or quoted-printable. The returned value is Chilkat's normalized serialization of the body, not necessarily the exact text that appeared in the loaded MIME. For example, Base64 padding and line wrapping or quoted-printable spelling may be regenerated. Returns True for success, False for failure. ### Mime.GetDecryptCertInfo `Chilkat 11.7.0 · pascal · Mime · GetDecryptCertInfo · method · since 11.4.0` ```pascal // certInfo is a TJsonObject object. function GetDecryptCertInfo(certInfo: TChilkatBase): Boolean; ``` Examines the current encrypted S/MIME entity and writes recipient-certificate identifiers to the `JsonObject` in `certInfo`. This can be used to identify which certificate and private key must be made available before calling `Decrypt` or `UnwrapSecurity`. A typical result is: ``` { "recipientInfo": [ { "serial": "166FC256FC66A64B20C710F15BFAB63E", "issuerCN": "Example Issuing CA" } ] } ``` The method returns `False` and writes an empty JSON object when the current MIME entity is not encrypted, including after it has already been decrypted. **No private key is revealed.** The encrypted message contains recipient identifiers and encrypted key material, not recipient private keys. Returns True for success, False for failure. ### Mime.GetEntireBody `Chilkat 11.7.0 · pascal · Mime · GetEntireBody · method` ```pascal function GetEntireBody: string; ``` Returns the complete serialized body of the current MIME entity. For multipart MIME, this includes boundary delimiters, each child part's headers and body, and the closing boundary. The current entity's own header fields are not included. Use `GetBodyDecoded` when the decoded payload of a single part is needed. Returns True for success, False for failure. ### Mime.GetEntireHead `Chilkat 11.7.0 · pascal · Mime · GetEntireHead · method` ```pascal function GetEntireHead: string; ``` Returns the complete serialized header section of the current MIME entity. The body and any multipart child content are not included. Returns True for success, False for failure. ### Mime.GetHeaderField `Chilkat 11.7.0 · pascal · Mime · GetHeaderField · method` ```pascal function GetHeaderField(const fieldName: string): string; ``` Returns the value of the first header field whose name matches `fieldName` case-insensitively. Duplicate later occurrences are not combined. Returns null when no matching field exists. Returns True for success, False for failure. ### Mime.GetHeaderFieldAttribute `Chilkat 11.7.0 · pascal · Mime · GetHeaderFieldAttribute · method` ```pascal function GetHeaderFieldAttribute(const name: string;     const attrName: string): string; ``` Returns an attribute value parsed from the first header field named by `name`. Both the header name and `attrName` attribute name are matched case-insensitively. Surrounding quotation marks are removed, and semicolons inside a quoted value are handled as part of the value. Extended parameters such as `filename*=utf-8''r%C3%A9sum%C3%A9.txt` are returned in their raw encoded form; this method does not percent-decode or apply the declared charset. Returns null when the field or attribute is absent. Returns True for success, False for failure. ### Mime.GetHeaderFieldName `Chilkat 11.7.0 · pascal · Mime · GetHeaderFieldName · method` ```pascal function GetHeaderFieldName(index: Integer): string; ``` Returns the name of the header-field occurrence at zero-based `index`. Header order and original casing are preserved for ordinary loaded headers. Use `NumHeaderFields` to determine the valid range. Returns True for success, False for failure. ### Mime.GetHeaderFieldValue `Chilkat 11.7.0 · pascal · Mime · GetHeaderFieldValue · method` ```pascal function GetHeaderFieldValue(index: Integer): string; ``` Returns the unfolded value of the header-field occurrence at zero-based `index`. Continuation lines are combined into a single value. Use `NumHeaderFields` to determine the valid range. Returns True for success, False for failure. ### Mime.GetLastJsonData `Chilkat 11.7.0 · pascal · Mime · GetLastJsonData · method · since 9.5.0.69` ```pascal // json is a TJsonObject object. procedure GetLastJsonData(json: TChilkatBase); ``` Copies structured details from the most recent operation into `json` when such details are available. Many methods do not produce JSON data. | Operation | Typical result | | :--- | :--- | | Signing or encryption | An empty JSON object. | | `Verify` | `pkcs7.verify` details such as embedded certificates, digest algorithms, signer information, signature algorithm, signing time, message digest, and authenticated attributes. | | Decryption | `pkcs7.decrypt` details including the content algorithm and key size. A PFX-based method may also include PKCS #12 parsing details. | | `UnwrapSecurity` | May contain both verification and decryption sections when both kinds of security layer were removed. | **Read immediately.** The information describes the most recent applicable call on this object and can be replaced by a later operation. ### Mime.GetMime `Chilkat 11.7.0 · pascal · Mime · GetMime · method` ```pascal function GetMime: string; ``` Serializes and returns the complete MIME entity, including headers, body, multipart boundaries, and all descendants. **Serialization is normalized.** The result is semantically equivalent MIME, not a byte-for-byte copy of loaded input. Chilkat can unfold headers, normalize parameter quoting and transfer encodings, discard multipart preamble and epilogue text, and generate CRLF for headers and multipart framing. Existing body line endings may not always be rewritten. Returns True for success, False for failure. ### Mime.GetMimeBd `Chilkat 11.7.0 · pascal · Mime · GetMimeBd · method · since 9.5.0.62` ```pascal // bindat is a TBinData object. function GetMimeBd(bindat: TChilkatBase): Boolean; ``` Serializes the complete MIME entity and appends its bytes to `bindat`. Existing `BinData` bytes are preserved. Use this method when arbitrary binary body bytes must not pass through a text string. **Serialization is normalized.** The result is semantically equivalent MIME, not a byte-for-byte copy of loaded input. Chilkat can unfold headers, normalize parameter quoting and transfer encodings, discard multipart preamble and epilogue text, and generate CRLF for headers and multipart framing. Existing body line endings may not always be rewritten. Returns True for success, False for failure. ### Mime.GetMimeSb `Chilkat 11.7.0 · pascal · Mime · GetMimeSb · method · since 9.5.0.62` ```pascal // sb is a TStringBuilder object. function GetMimeSb(sb: TChilkatBase): Boolean; ``` Serializes the complete MIME entity and appends it to `sb`. Existing `StringBuilder` content is preserved. **Serialization is normalized.** The result is semantically equivalent MIME, not a byte-for-byte copy of loaded input. Chilkat can unfold headers, normalize parameter quoting and transfer encodings, discard multipart preamble and epilogue text, and generate CRLF for headers and multipart framing. Existing body line endings may not always be rewritten. Returns True for success, False for failure. ### Mime.GetSignatureSigningTimeStr `Chilkat 11.7.0 · pascal · Mime · GetSignatureSigningTimeStr · method` ```pascal function GetSignatureSigningTimeStr(index: Integer): string; ``` Returns the CMS `signingTime` signed attribute for the signer at zero-based `index`, formatted as an RFC 822-style date string in GMT. For example: ``` Wed, 29 Jul 2026 14:32:58 GMT ``` Call `HasSignatureSigningTime` first because the attribute is optional. Use `NumSignerCerts` for the signer count. **Signing time is not a trusted timestamp.** The CMS `signingTime` value is supplied by the signer. It is different from a timestamp token issued and signed by a trusted timestamp authority. Returns True for success, False for failure. ### Mime.GetStructure `Chilkat 11.7.0 · pascal · Mime · GetStructure · method · since 9.5.0.56` ```pascal function GetStructure(const fmt: string): string; ``` Returns a concise MIME-tree summary. `fmt` is case-insensitive. The value `xml` selects XML output; all other values, including `text`, an empty string, or an unrecognized value, select the indented text format. ``` multipart/mixed text/plain application/octet-stream ``` ``` ``` Returns True for success, False for failure. ### Mime.GetXml `Chilkat 11.7.0 · pascal · Mime · GetXml · method` ```pascal function GetXml: string; ``` Converts the MIME tree to Chilkat's XML representation and returns it as a string. Header names become XML element names, structured header parameters become XML attributes, duplicate headers become repeated elements, multipart children are nested in `subpart` elements, and binary bodies are represented in an encoded textual form. **XML round-tripping is semantic.** Loading this XML reconstructs an equivalent MIME tree, but it is not byte-preserving and header names are normalized to lowercase. Returns True for success, False for failure. ### Mime.HasSignatureSigningTime `Chilkat 11.7.0 · pascal · Mime · HasSignatureSigningTime · method` ```pascal function HasSignatureSigningTime(index: Integer): Boolean; ``` Returns `True` if the signer at zero-based `index` has a CMS `signingTime` signed attribute. Use `NumSignerCerts` for the signer count and `GetSignatureSigningTimeStr` to retrieve the value. ### Mime.IsApplicationData `Chilkat 11.7.0 · pascal · Mime · IsApplicationData · method` ```pascal function IsApplicationData: Boolean; ``` Returns `True` when `ContentType` begins with `application/`. It returns `False` for an empty or malformed media type. ### Mime.IsAttachment `Chilkat 11.7.0 · pascal · Mime · IsAttachment · method` ```pascal function IsAttachment: Boolean; ``` Returns `True` when the current part's disposition value is `attachment`, matched case-insensitively. Parameters such as `filename` do not affect the test. An `inline` part remains non-attachment even when it has a filename. ### Mime.IsAudio `Chilkat 11.7.0 · pascal · Mime · IsAudio · method` ```pascal function IsAudio: Boolean; ``` Returns `True` when `ContentType` begins with `audio/`. ### Mime.IsEncrypted `Chilkat 11.7.0 · pascal · Mime · IsEncrypted · method` ```pascal function IsEncrypted: Boolean; ``` Returns `True` when the current MIME entity is a CMS/PKCS #7 encrypted S/MIME wrapper. Both `application/pkcs7-mime` and `application/x-pkcs7-mime` forms are recognized. To search the visible MIME tree rather than only the current entity, use `ContainsEncryptedParts`. ### Mime.IsHtml `Chilkat 11.7.0 · pascal · Mime · IsHtml · method` ```pascal function IsHtml: Boolean; ``` Returns `True` when `ContentType` is `text/html`. The `ContentType` property must contain only the media type; set parameters such as `charset` separately. ### Mime.IsImage `Chilkat 11.7.0 · pascal · Mime · IsImage · method` ```pascal function IsImage: Boolean; ``` Returns `True` when `ContentType` begins with `image/`, including values such as `image/svg+xml`. ### Mime.IsMultipart `Chilkat 11.7.0 · pascal · Mime · IsMultipart · method` ```pascal function IsMultipart: Boolean; ``` Returns `True` when `ContentType` begins with `multipart/`. ### Mime.IsMultipartAlternative `Chilkat 11.7.0 · pascal · Mime · IsMultipartAlternative · method` ```pascal function IsMultipartAlternative: Boolean; ``` Returns `True` when `ContentType` is `multipart/alternative`. ### Mime.IsMultipartMixed `Chilkat 11.7.0 · pascal · Mime · IsMultipartMixed · method` ```pascal function IsMultipartMixed: Boolean; ``` Returns `True` when `ContentType` is `multipart/mixed`. ### Mime.IsMultipartRelated `Chilkat 11.7.0 · pascal · Mime · IsMultipartRelated · method` ```pascal function IsMultipartRelated: Boolean; ``` Returns `True` when `ContentType` is `multipart/related`. ### Mime.IsPlainText `Chilkat 11.7.0 · pascal · Mime · IsPlainText · method` ```pascal function IsPlainText: Boolean; ``` Returns `True` when `ContentType` is `text/plain`. ### Mime.IsSigned `Chilkat 11.7.0 · pascal · Mime · IsSigned · method` ```pascal function IsSigned: Boolean; ``` Returns `True` when the current MIME entity is a complete CMS/PKCS #7 signed S/MIME wrapper, including detached `multipart/signed` and opaque signed-data forms. A standalone `application/pkcs7-signature` or `application/x-pkcs7-signature` leaf part is not by itself classified as a signed message. To search the visible MIME tree, use `ContainsSignedParts`. ### Mime.IsText `Chilkat 11.7.0 · pascal · Mime · IsText · method` ```pascal function IsText: Boolean; ``` Returns `True` when `ContentType` begins with `text/`. ### Mime.IsVideo `Chilkat 11.7.0 · pascal · Mime · IsVideo · method` ```pascal function IsVideo: Boolean; ``` Returns `True` when `ContentType` begins with `video/`. ### Mime.IsXml `Chilkat 11.7.0 · pascal · Mime · IsXml · method` ```pascal function IsXml: Boolean; ``` Returns `True` only for `text/xml` or `application/xml`. It does not classify structured-suffix media types such as `application/soap+xml`, `application/atom+xml`, or `image/svg+xml` as XML. ### Mime.LastDecryptCert `Chilkat 11.7.0 · pascal · Mime · LastDecryptCert · method · since 11.0.0` ```pascal // cert is a TCert object. function LastDecryptCert(index: Integer;     cert: TChilkatBase): Boolean; ``` Loads into `cert` the decryption certificate at zero-based `index` from the most recent successful decryption or security-unwrapping operation. Valid indexes range from `0` through `NumDecryptCerts` `- 1`. The returned certificate has access to the private key used for decryption. An invalid index returns `False` and leaves `cert` unchanged. Returns True for success, False for failure. ### Mime.LastSignerCert `Chilkat 11.7.0 · pascal · Mime · LastSignerCert · method · since 11.0.0` ```pascal // cert is a TCert object. function LastSignerCert(index: Integer;     cert: TChilkatBase): Boolean; ``` Loads into `cert` the signer certificate at zero-based `index` from the most recent successful signature-verification or security-unwrapping operation. Valid indexes range from `0` through `NumSignerCerts` `- 1`. The returned certificate normally contains only the public key; it does not gain access to the signer's private key. An invalid index returns `False` and leaves `cert` unchanged. A later failed call to `Verify` clears the signer results. Returns True for success, False for failure. ### Mime.LoadMime `Chilkat 11.7.0 · pascal · Mime · LoadMime · method` ```pascal function LoadMime(const mimeMsg: string): Boolean; ``` Parses the complete MIME text in `mimeMsg` and replaces the current object's headers, body, and multipart tree. A successful call always replaces the previous MIME. If no blank line separates headers from the body, lines that appear header-like are parsed as headers and the body is empty. Data after the header/body separator belongs to the body. **Permissive parser and normalized output.** Chilkat accepts many imperfect messages. Observed behavior includes ignoring malformed header lines and leading non-header text, using the last duplicate `Content-Type`, repairing a missing multipart closing delimiter during serialization, treating unmatched boundary-like text as an ordinary body, and tolerating malformed Base64 or quoted-printable. LF-only and CR-only input are accepted; generated headers and multipart framing use CRLF. Loading and reserializing is therefore not guaranteed to reproduce the original bytes, and multipart preamble and epilogue text are not retained. **Text input is not a raw-byte container.** Use `LoadMimeBd` or `LoadMimeBytes` for arbitrary 8-bit bytes or embedded NUL bytes. Returns True for success, False for failure. ### Mime.LoadMimeBd `Chilkat 11.7.0 · pascal · Mime · LoadMimeBd · method · since 9.5.0.62` ```pascal // bindat is a TBinData object. function LoadMimeBd(bindat: TChilkatBase): Boolean; ``` Parses complete MIME bytes from `bindat` and replaces the current MIME on success. This is the preferred loader when the MIME can contain arbitrary 8-bit body bytes or embedded NUL bytes. Parsing tolerance and serialization normalization are the same as `LoadMime`. Returns True for success, False for failure. ### Mime.LoadMimeFile `Chilkat 11.7.0 · pascal · Mime · LoadMimeFile · method` ```pascal function LoadMimeFile(const fileName: string): Boolean; ``` Reads and parses the complete MIME entity from the local file at `fileName`. A successful call replaces the current MIME. If the file cannot be opened, the method returns `False` and preserves the existing object unchanged. Parsing tolerance and serialization normalization are the same as `LoadMime`. Returns True for success, False for failure. ### Mime.LoadMimeSb `Chilkat 11.7.0 · pascal · Mime · LoadMimeSb · method · since 9.5.0.62` ```pascal // sb is a TStringBuilder object. function LoadMimeSb(sb: TChilkatBase): Boolean; ``` Parses complete MIME text from `sb` and replaces the current MIME on success. Parsing tolerance and serialization normalization are the same as `LoadMime`. **Use byte input for arbitrary MIME bytes.** A `StringBuilder` is text-oriented. Use `LoadMimeBd` for binary MIME containing arbitrary 8-bit values or NUL bytes. Returns True for success, False for failure. ### Mime.LoadXml `Chilkat 11.7.0 · pascal · Mime · LoadXml · method` ```pascal function LoadXml(const xml: string): Boolean; ``` Reconstructs a MIME tree from Chilkat's MIME XML in `xml`. On success, the current object is replaced. If the XML is invalid, the method returns `False` and preserves the existing MIME unchanged. The reconstructed MIME is semantically equivalent but not byte-identical to the MIME that produced the XML. Header names are normalized to lowercase. Returns True for success, False for failure. ### Mime.LoadXmlFile `Chilkat 11.7.0 · pascal · Mime · LoadXmlFile · method` ```pascal function LoadXmlFile(const fileName: string): Boolean; ``` Reads Chilkat MIME XML from the local file at `fileName` and reconstructs the MIME tree. On success, the current object is replaced. If the file cannot be opened or the XML is invalid, the method returns `False` and preserves the existing MIME unchanged. Header names are normalized to lowercase during reconstruction. Returns True for success, False for failure. ### Mime.NewMessageRfc822 `Chilkat 11.7.0 · pascal · Mime · NewMessageRfc822 · method` ```pascal // mimeObject is a TMime object. function NewMessageRfc822(mimeObject: TChilkatBase): Boolean; ``` Clears the current object and initializes it as `message/rfc822`. Its body is a serialized copy of `mimeObject` at the time of the call. Later modifications to `mimeObject` do not change the embedded message. Returns True for success, False for failure. ### Mime.NewMultipartAlternative `Chilkat 11.7.0 · pascal · Mime · NewMultipartAlternative · method` ```pascal function NewMultipartAlternative: Boolean; ``` Initializes an empty `multipart/alternative` entity. Clears all existing headers, body content, and child parts. The new object contains only a multipart `Content-Type` with an automatically generated boundary, has zero parts, and does not automatically add `MIME-Version`. Returns True for success, False for failure. ### Mime.NewMultipartMixed `Chilkat 11.7.0 · pascal · Mime · NewMultipartMixed · method` ```pascal function NewMultipartMixed: Boolean; ``` Initializes an empty `multipart/mixed` entity. Clears all existing headers, body content, and child parts. The new object contains only a multipart `Content-Type` with an automatically generated boundary, has zero parts, and does not automatically add `MIME-Version`. Returns True for success, False for failure. ### Mime.NewMultipartRelated `Chilkat 11.7.0 · pascal · Mime · NewMultipartRelated · method` ```pascal function NewMultipartRelated: Boolean; ``` Initializes an empty `multipart/related` entity. Clears all existing headers, body content, and child parts. The new object contains only a multipart `Content-Type` with an automatically generated boundary, has zero parts, and does not automatically add `MIME-Version`. Returns True for success, False for failure. ### Mime.PartAt `Chilkat 11.7.0 · pascal · Mime · PartAt · method · since 11.0.0` ```pascal // subPart is a TMime object. function PartAt(index: Integer;     subPart: TChilkatBase): Boolean; ``` Provides live access to the direct child at zero-based `index` through `subPart`. Modifying `subPart` after a successful call modifies the child stored in the parent MIME tree. Valid indexes range from `0` through `NumParts` `- 1`. An invalid index returns `False` and preserves `subPart` unchanged. **Different from AppendPart.** `AppendPart` stores a copy of its argument. This method exposes the actual stored child. Returns True for success, False for failure. ### Mime.PartsToFiles `Chilkat 11.7.0 · pascal · Mime · PartsToFiles · method · since 11.0.0` ```pascal // st is a TStringTable object. function PartsToFiles(const path: string;     st: TChilkatBase): Boolean; ``` Recursively traverses the MIME tree and saves each part having a nonempty `filename` parameter to the existing directory in `path`. A `name` parameter alone is not used as a fallback. The disposition may be `attachment` or `inline`; a filename is what controls extraction. - Only the final path component of a MIME filename is used. Directory components, absolute paths, and `..` traversal are discarded. - On Windows, invalid filename characters are replaced with underscores. - Duplicate filenames target the same path; later parts overwrite earlier parts. - `st` is appended to rather than cleared. Each added entry is the full path actually written, including any sanitized filename. - The destination directory is not created. If it does not exist, the method returns `False`, creates no files, and appends nothing to `st`. **Treat MIME filenames as untrusted.** Use a controlled destination directory and apply any application-specific policy for file types, size limits, overwriting, and renaming. Returns True for success, False for failure. ### Mime.RemoveHeaderField `Chilkat 11.7.0 · pascal · Mime · RemoveHeaderField · method` ```pascal procedure RemoveHeaderField(const fieldName: string;     bAllOccurrences: Boolean); ``` Removes fields whose name matches `fieldName` case-insensitively. If `bAllOccurrences` is `False`, only the first matching occurrence is removed. If `bAllOccurrences` is `True`, all matching occurrences are removed. Remaining fields retain their relative order. ### Mime.RemovePart `Chilkat 11.7.0 · pascal · Mime · RemovePart · method` ```pascal function RemovePart(index: Integer): Boolean; ``` Removes the direct child at zero-based `index`. Valid indexes range from `0` through `NumParts` `- 1`. An out-of-range index returns `False` and leaves the tree unchanged. Returns True for success, False for failure. ### Mime.SaveBody `Chilkat 11.7.0 · pascal · Mime · SaveBody · method` ```pascal function SaveBody(const filename: string): Boolean; ``` Writes the decoded body bytes of the current part to the local path in `filename`. Base64 and quoted-printable are decoded. MIME headers and multipart framing are not written. **File behavior.** Existing files are overwritten. Parent directories are not created, and passing a directory as the destination fails. On Windows, an existing read-only file is replaced and the read-only attribute is removed. Returns True for success, False for failure. ### Mime.SaveMime `Chilkat 11.7.0 · pascal · Mime · SaveMime · method` ```pascal function SaveMime(const filename: string): Boolean; ``` Serializes the complete MIME entity and writes it to the local path in `filename`, including headers, body, multipart boundaries, and all descendants. **Serialization is normalized.** The result is semantically equivalent MIME, not a byte-for-byte copy of loaded input. Chilkat can unfold headers, normalize parameter quoting and transfer encodings, discard multipart preamble and epilogue text, and generate CRLF for headers and multipart framing. Existing body line endings may not always be rewritten. **File behavior.** Existing files are overwritten. Parent directories are not created, and passing a directory as the destination fails. On Windows, an existing read-only file is replaced and the read-only attribute is removed. Returns True for success, False for failure. ### Mime.SaveXml `Chilkat 11.7.0 · pascal · Mime · SaveXml · method` ```pascal function SaveXml(const filename: string): Boolean; ``` Writes Chilkat's MIME XML representation to the local path in `filename`. The file can be loaded by `LoadXmlFile`. **File behavior.** Existing files are overwritten. Parent directories are not created, and passing a directory as the destination fails. On Windows, an existing read-only file is replaced and the read-only attribute is removed. Returns True for success, False for failure. ### Mime.SetBody `Chilkat 11.7.0 · pascal · Mime · SetBody · method` ```pascal procedure SetBody(const str: string); ``` Sets the current part's body from `str` while preserving existing content headers such as `Content-Type`, `charset`, and `Content-Transfer-Encoding`. **Multipart entities serialize their child parts.** Calling this method on a multipart object changes what the body getter methods return, but the assigned body is not included in the serialized multipart output while child parts are present. Build multipart content through `AppendPart` and `PartAt`. ### Mime.SetBodyBd `Chilkat 11.7.0 · pascal · Mime · SetBodyBd · method · since 11.0.0` ```pascal // bd is a TBinData object. function SetBodyBd(bd: TChilkatBase): Boolean; ``` Sets the decoded body bytes from `bd`, changes `Content-Transfer-Encoding` to `base64`, and preserves the bytes exactly. It does not set a `Content-Type`, disposition, filename, or name; set those separately when needed. Returns True for success, False for failure. ### Mime.SetBodyFromEncoded `Chilkat 11.7.0 · pascal · Mime · SetBodyFromEncoded · method` ```pascal function SetBodyFromEncoded(const encoding: string;     const str: string): Boolean; ``` Sets the body from transfer-encoded text. `encoding` must be `base64` or `quoted-printable`; other values, including `7bit`, `8bit`, `binary`, an unknown name, or an empty string, cause failure. Base64 whitespace is accepted and the stored representation is normalized. Invalid Base64 causes the method to return `False`. On any failure, all existing headers and body content are preserved unchanged. **Do not encode twice.** `str` must already be in the encoding named by `encoding`. To provide decoded bytes, use `SetBodyBd` or `SetBodyFromBinary`. Returns True for success, False for failure. ### Mime.SetBodyFromFile `Chilkat 11.7.0 · pascal · Mime · SetBodyFromFile · method` ```pascal function SetBodyFromFile(const fileName: string): Boolean; ``` Reads the local file at `fileName` and replaces the current part's body and content headers according to the filename extension. | File kind | Result | | :--- | :--- | | `.txt` | `text/plain; charset=windows-1252; format=flowed`, `7bit` | | `.html` | `text/html; charset=windows-1252`, `7bit` | | Unknown extension | `application/octet-stream`, `base64`, `attachment`, and filename/name parameters based on the local filename | If the file cannot be opened, the method returns `False` and preserves the existing MIME unchanged. Returns True for success, False for failure. ### Mime.SetBodyFromHtml `Chilkat 11.7.0 · pascal · Mime · SetBodyFromHtml · method` ```pascal function SetBodyFromHtml(const str: string): Boolean; ``` Sets `str` as HTML and changes the media type to `text/html`. For ASCII input, Chilkat uses `Content-Transfer-Encoding: 7bit` and does not add a charset. Existing unrelated headers are preserved. Returns True for success, False for failure. ### Mime.SetBodyFromPlainText `Chilkat 11.7.0 · pascal · Mime · SetBodyFromPlainText · method` ```pascal function SetBodyFromPlainText(const str: string): Boolean; ``` Sets `str` as plain text. For ASCII input, Chilkat sets `Content-Type: text/plain; format=flowed` and `Content-Transfer-Encoding: 7bit` without a charset. For non-ASCII UTF-8 input, it sets `charset=utf-8` and uses `8bit`. Existing unrelated headers are preserved. Returns True for success, False for failure. ### Mime.SetBodyFromXml `Chilkat 11.7.0 · pascal · Mime · SetBodyFromXml · method` ```pascal function SetBodyFromXml(const str: string): Boolean; ``` Sets `str` as XML, changes the media type to `text/xml`, and selects a transfer encoding appropriate for the text. For ASCII input, Chilkat uses `7bit` and does not add a charset. The XML declaration's `encoding` value is not copied to the MIME `charset` parameter. **Different from LoadXml.** This method places an XML document in the MIME body. `LoadXml` reconstructs an entire MIME object from Chilkat MIME XML. Returns True for success, False for failure. ### Mime.SetHeaderField `Chilkat 11.7.0 · pascal · Mime · SetHeaderField · method` ```pascal function SetHeaderField(const name: string;     const value: string): Boolean; ``` Sets one header field named by `name`. Matching is case-insensitive. All existing occurrences are removed and one replacement is inserted. If no field exists, a new one is added. Passing an empty `value` removes all matching occurrences rather than creating an empty-valued field. Use `AddHeaderField` to append another occurrence or to create an empty-valued field. Returns True for success, False for failure. ### Mime.SetVerifyCert `Chilkat 11.7.0 · pascal · Mime · SetVerifyCert · method` ```pascal // cert is a TCert object. function SetVerifyCert(cert: TChilkatBase): Boolean; ``` Supplies `cert` as a signer-certificate fallback for subsequent signature verification. This is useful when the CMS/PKCS #7 signature does not embed the signer certificate and Chilkat cannot otherwise locate it. Only the public key is required. **This does not require a particular signer.** An embedded signer certificate takes precedence. If the CMS signature embeds the correct signer certificate, verification can succeed even when `cert` is an unrelated certificate, and `LastSignerCert` returns the embedded certificate. To enforce signer identity, verify first and then compare the returned signer certificate using application-defined criteria such as its serial number, fingerprint, subject, issuer, or trusted chain. Returns True for success, False for failure. ### Mime.UnwrapSecurity `Chilkat 11.7.0 · pascal · Mime · UnwrapSecurity · method` ```pascal function UnwrapSecurity: Boolean; ``` Removes supported S/MIME security layers and restores the underlying MIME content. It handles both common layer orders: a message signed and then encrypted, and a message encrypted and then signed. It continues through nested top-level layers until no additional supported security wrapper remains. After a successful call, `NumSignerCerts` and `LastSignerCert` identify verified signers, while `NumDecryptCerts` and `LastDecryptCert` identify decryption certificates. `GetLastJsonData` may contain both `pkcs7.verify` and `pkcs7.decrypt` details. **Additional result headers.** When `UnwrapExtras` is `True`, Chilkat adds headers such as `X-NumPartsSigned`, `X-SignaturesValid`, `X-NumPartsEncrypted`, and `X-Decrypted`. Set it to `False` to omit these headers. Returns True for success, False for failure. ### Mime.UrlEncodeBody `Chilkat 11.7.0 · pascal · Mime · UrlEncodeBody · method` ```pascal procedure UrlEncodeBody(const charset: string); ``` Replaces the current body with an `application/x-www-form-urlencoded`-style representation using the character set named by `charset`. Spaces become `+`, a literal plus becomes `%2B`, non-ASCII bytes become `%HH` sequences, and separators such as `&` and `=` remain unchanged. ``` Input: a b+c&d=e Output: a+b%2Bc&d=e ``` The MIME content headers are not changed. If the named character set is unsupported, the body remains unchanged. **Not a MIME transfer encoding.** This operation is distinct from `base64` and `quoted-printable`. ### Mime.UseCertVault `Chilkat 11.7.0 · pascal · Mime · UseCertVault · method` ```pascal // vault is a TXmlCertVault object. function UseCertVault(vault: TChilkatBase): Boolean; ``` Sets `vault` as the certificate vault used to locate certificates and private keys for S/MIME encryption, decryption, signing, and verification. Only one vault is active; each call replaces the previously configured vault. Use `XmlCertVault` when credentials are maintained independently of platform certificate stores or individual PFX sources. Returns True for success, False for failure. ### Mime.Verify `Chilkat 11.7.0 · pascal · Mime · Verify · method` ```pascal function Verify: Boolean; ``` Verifies the current CMS/PKCS #7 signed MIME entity and removes the signature wrapper. Both detached `multipart/signed` messages and opaque CMS `signed-data` are supported. The method works with signed MIME loaded from serialized input as well as MIME signed by the current object. On success, the object is restored to the MIME structure and content that was signed, `NumSignerCerts` reports the verified signer count, `LastSignerCert` returns the signer certificate, and `GetLastJsonData` reports CMS verification details. A detached signature can restore the original serialization exactly, but opaque signed-data restoration is semantic and is not guaranteed to reproduce byte-for-byte identical MIME serialization. On failure, the signed wrapper remains unchanged, no content is unwrapped, and the signer-result count is cleared to `0`. **SetVerifyCert is a fallback, not a signer restriction.** When the CMS data embeds a usable signer certificate, Chilkat uses that embedded certificate. Verification can therefore succeed even when `SetVerifyCert` was given an unrelated certificate. Enforce signer identity after verification by examining `LastSignerCert`. **What verification proves.** Cryptographic verification establishes that the signed bytes have not changed and that the signature matches the signer certificate. Application trust decisions may additionally require validating the certificate chain, identity, usage, validity period, and revocation status. Returns True for success, False for failure. ## Related classes [`BinData`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/pascal/classes/BinData.md), [`Cert`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/pascal/classes/Cert.md), [`JsonObject`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/pascal/classes/JsonObject.md), [`PrivateKey`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/pascal/classes/PrivateKey.md), [`StringBuilder`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/pascal/classes/StringBuilder.md), [`StringTable`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/pascal/classes/StringTable.md), [`XmlCertVault`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/pascal/classes/XmlCertVault.md)