Install a Snowflake Native App, get native SQL functions you can drop into any query, Stream, Task, or Dynamic Table.
Enigmata Cipher for Snowflake ships as a Snowflake Native App from the Marketplace. It exposes Enigmata Cipher’s three pillars as native SQL functions you call inline: in ingestion pipelines, materialized views, Streams + Tasks, Dynamic Tables, even Snowflake Data Sharing. The app runs in Snowpark Container Services inside your Snowflake account, bound to a key held under your Tri-Secret Secure customer-managed HSM root. Encrypted columns stay joinable, sortable, and rankable, so Cortex and analytics keep working. Your plaintext never needs to leave your premises. Run Enigmata Cipher’s signed confidential-VM image on-prem to encrypt your data, and upload only ciphertext to a Snowflake stage. Your Snowflake account sees ciphertext, never plaintext.
Query parity: every JOIN, GROUP BY, and ORDER BY against encrypted columns returns the same row-count and ordering as against plaintext.
External network calls per encrypted row; everything runs inside your Snowflake account in Snowpark Container Services.
Encrypt and compare functions live in your SQL: no client library, no per-row UDF marshaling overhead.
Snowflake Data Sharing between two accounts can JOIN on encrypted IDs without either account holding the other’s plaintext.
What this unlocks for you
Multi-party clean rooms, without the Clean Room
Two firms encrypt customer-identifier columns under the same context (KMS-shared between accounts); their Snowflake accounts `JOIN` on encrypted IDs and aggregate without either firm ever seeing the other’s underlying records. The Snowflake Clean Room product solves one shape of this; Enigmata Cipher works in every SQL context, including Data Sharing.
Encrypt at ingestion, query everywhere
Wrap raw columns in Enigmata Cipher's encrypt functions in your `COPY INTO` or Stream pipeline; every downstream query sees the encrypted column and runs without rewriting itself.
Cortex Search on encrypted text
Index encrypted token streams; lexical retrieval still works because equality is preserved. The vendor LLM never sees raw document content even when answering customer queries.
Vector search that doesn’t leak embeddings
Encrypt Cortex-generated embeddings in place, then rank them with Enigmata Cipher's similarity function at query time; the original embedding never sits in a vector index where a misconfigured share could surface it.
Three pillars, preserved
Text: equality preserved in SQL
`JOIN`, `GROUP BY`, `DISTINCT`, `WHERE = ?`, and `IN (...)` all work directly on encrypted columns. Identical plaintext always produces the same encrypted VARCHAR, and Snowflake’s micro-partition pruning still applies.
Numeric: order preserved in SQL
`ORDER BY`, `BETWEEN`, percentile aggregates (`PERCENTILE_CONT`, `MEDIAN`), window functions, and range partition pruning all work on encrypted numbers without decrypting.
Vector: cosine similarity exposed as a SQL function
Enigmata Cipher's similarity function returns a FLOAT in the same range Snowflake’s `VECTOR_COSINE_SIMILARITY` would; encrypted embeddings rank the same way plaintext would.
How customers install it
Install Enigmata Cipher Encryption for Snowflake from Snowflake Marketplace in your account. The Native App handles the Snowpark Container Services deployment automatically.
Bind the app’s service principal to your Tri-Secret Secure KMS key. The Native App’s setup script walks you through the `GRANT USAGE` statements; no manual key handoff.
Define an encryption context that maps each column to its type (text, numeric, or vector) using the Enigmata Cipher SDK; see the Enigmata Cipher SDK docs for the exact call. On-prem: the signed Enigmata Cipher confidential-VM image attests to your KMS, derives the seed inside your facility, and uploads the wrapped manifest to a Native App-owned stage so the in-account functions can reference the same context. In-account alternative: the app HKDF-derives the seed inside its Snowpark container and persists the wrapped manifest to the same stage.
On-prem: encrypt your source data with the confidential-VM image and `COPY INTO` ciphertext directly to your Snowflake table. Downstream `JOIN`, `GROUP BY`, `ORDER BY`, and similarity-search queries read the ciphertext as usual. In-account alternative: wrap each column in the matching Enigmata Cipher encrypt function inside an `INSERT ... SELECT` from your raw table into the secured table, then query downstream the same way. The Enigmata Cipher SDK docs show the full statement.
Where it fits
Best fit: Snowflake-first data teams who want column-level encryption that survives JOIN, GROUP BY, and ORDER BY, and accounts that share data with partners via Snowflake Data Sharing or build vendor data products on the Marketplace.
Financial Services
Two firms encrypt customer identifiers across their Snowflake accounts and JOIN for fraud-syndicate detection or customer-overlap analytics without either firm seeing the other’s underlying records.
Healthcare
Encrypt ePHI on `COPY INTO`; clinicians query patient cohorts on the encrypted columns without de-identifying on every query; Cortex Search runs over encrypted clinical narratives.
Retail + CPG
Encrypt loyalty IDs before publishing a data product to Snowflake Marketplace; partner brands attribute campaigns on encrypted IDs in their own accounts.
Government
Sovereign-data Snowflake deployments where regulators require column-level encryption at rest AND inside the compute path AND under customer-held keys.
How it compares
The honest framing of every other option.
| Approach | What you get |
|---|---|
| Snowflake’s built-in `ENCRYPT()` function | Symmetric AES; the result is opaque so you lose every query property except equality on identical inputs (and even that requires deterministic mode, which Snowflake’s docs explicitly discourage). |
| Dynamic Data Masking + Row Access Policies | Strong access control at query time, but the underlying data is still plaintext at rest in the storage layer, and visible to anyone who can read the unmasked view. |
| External tokenization vaults via External Functions | Adds a per-row network call out of Snowflake to a Skyflow / TokenEx / similar vault; analytics queries grind to a halt at any real scale and the vault becomes a SPOF for every Snowflake workload. |
| Snowflake Clean Rooms | Powerful for governed multi-party joins, but locks you into the Clean Room execution model and the Clean Room party-config workflow. Enigmata Cipher works anywhere a SQL function does, including Data Sharing without Clean Room. |
| Enigmata Cipher | SQL-native, key-vault-keyed via Tri-Secret Secure, no per-row network hop, works in every Snowflake context that takes a function call. |
Key capabilities
- SQL-native functions from the Enigmata Cipher SDK encrypt text, numeric, and vector columns inline, plus a keyless cosine-compare function for similarity search.
- Customer-managed key via Snowflake Tri-Secret Secure (your AWS KMS, Azure Key Vault, or GCP Cloud KMS HSM root).
- Native App distribution: install from Snowflake Marketplace; runs in Snowpark Container Services in your account; no data leaves your perimeter.
- Three pillars preserved as SQL semantics: equality for `JOIN`/`GROUP BY`, order for `ORDER BY`/range filters, cosine for the similarity function and Cortex Search.
- Works in any SQL context: `SELECT`, `INSERT`, `MERGE`, `CREATE TABLE AS`, materialized views, Streams + Tasks, Dynamic Tables, Cortex Search index pipelines.
- Encrypted columns share cleanly via Snowflake Data Sharing, so partner accounts join on encrypted identifiers without ever seeing plaintext.
Technical detail
How the Native App delivers SQL-native encryption inside your Snowflake account.
Where the encryption step physically runs is the customer’s choice: on-prem, the signed Enigmata Cipher confidential-VM image reads plaintext inside your facility and `PUT`s ciphertext to a Snowflake stage. Plaintext never enters your Snowflake account. As an in-account alternative, the Enigmata Cipher Native App ships as a Snowflake application package containing (a) a Snowpark Container Services service that holds the encryption engine, (b) a set of stored procedures and SQL UDFs that route calls to that service, and (c) setup scripts that grant the app access to the customer’s Tri-Secret Secure key; SQL function invocations call the container service over Snowflake’s internal high-throughput RPC with no per-row network call outside the account. Both paths produce identical ciphertext. Encrypted text and numeric values return as VARCHAR; encrypted vectors return as a VARIANT object matching the same shape every Enigmata Cipher integration emits. Cosine similarity is exposed as a SQL function returning a FLOAT in [-1, 1].
- Native App distribution: install once from Marketplace; the app self-deploys its Snowpark Container Services service into the customer’s account.
- SQL UDFs work in any context that accepts a function: `SELECT`, `INSERT`, `MERGE`, materialized views, Streams + Tasks, Dynamic Tables, Cortex Search index pipelines.
- Tri-Secret Secure integration: seed wrap/unwrap happens inside the customer’s account using their KMS key as the outermost wrap; Enigmata never holds key material.
- Encrypted vector cells round-trip as a self-describing VARIANT object that carries the ciphertext bytes and the context fingerprint needed to rank them.
- Enigmata Cipher's similarity function exposes cosine compare as a no-key SQL function, usable by any consumer with `SELECT` privilege on the encrypted columns, including Data Sharing recipients who have no access to the Tri-Secret Secure root.
What it needs
A Snowflake account on a tier that supports Snowpark Container Services and Tri-Secret Secure (Business Critical or higher). A customer-held KMS key in AWS KMS, Azure Key Vault, or GCP Cloud KMS to serve as the Tri-Secret Secure root.
Who holds the key
Run encryption on-prem and your KMS releases the seed only to an attested, unmodified Enigmata Cipher confidential-VM image. Plaintext never leaves your facility and the seed never reaches Snowflake. Run encryption in-account as the alternative and Snowflake’s Tri-Secret Secure model holds the key: your KMS root (AWS KMS, Azure Key Vault, or GCP Cloud KMS HSM) plus Snowflake’s per-account key plus per-table key. The Enigmata Cipher Native App reads its seed from the customer-key-encrypted manifest stored in your Snowflake stage; the seed exists in memory only inside the Snowpark Container Services pod running in your account.
How it’s billed
Snowflake Marketplace billing: monthly per Snowflake account, plus Snowpark Container Services compute consumption (billed to your Snowflake account at the service’s standard rate). No additional storage cost beyond a small internal stage for the manifest. SQL function calls run inside the account; no per-row external network charges.
The offer
Prove it in 60 days.
Prove it in 60 days. Pick the Snowflake table your security team won’t let you share with a partner, even though the analytics they want would be valuable to both sides. We’ll encrypt the right columns under a Tri-Secret Secure key, configure a Data Sharing pair to your partner account, and ship the parity report + tri-key custody attestation that both procurement teams need.
- Encryption-parity benchmarkSide-by-side query plan and result-set parity for `JOIN` / `GROUP BY` / `ORDER BY` between plaintext and encrypted columns.
- Tri-Secret Secure custody attestationAccount-level key flow diagram with customer KMS root, per-account key, and per-table key; confirmation that Enigmata never sees the customer KMS key.
- Data Sharing parity reportMulti-account share scenario showing encrypted-column JOIN succeeding across recipient accounts in a different region.
- CISO + procurement dossierVendor-handling delta for the Native App, including the Snowpark Container Services execution boundary and the customer-KMS-rooted Tri-Secret Secure flow.