CCencrypt 0.3.0__tar.gz

ccencrypt-0.3.0/CCencrypt.egg-info/PKG-INFO

@@ -0,0 +1,214 @@
+Metadata-Version: 2.4
+Name: CCencrypt
+Version: 0.3.0
+Summary: Card encryption and tokenisation for Adyen, CyberSource, eWay, Stripe, Braintree, Shopify and PayDock
+Author: itsregza
+License: MIT
+Project-URL: Homepage, https://github.com/itsregza/CCencrypt
+Project-URL: Repository, https://github.com/itsregza/CCencrypt
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: cryptography>=42.0.0
+Requires-Dist: requests>=2.28.0
+
+<p align="center">
+  <img src="https://raw.githubusercontent.com/itsregza/CCencrypt/main/assets/banner.svg" alt="CCencrypt" width="520">
+</p>
+
+<p align="center">Card encryption and tokenisation for Python.</p>
+
+| Processor | Function | Type | Returns |
+|---|---|---|---|
+| Adyen | `ccadyen` | Encrypt | dict of 4 encrypted fields |
+| CyberSource Flex | `cccybersource` / `cccybersource_token` | Encrypt / Tokenise | JWE / transient token |
+| eWay | `cceway` / `cceway_card` | Encrypt | `eCrypted:...` strings |
+| Stripe | `ccstripe` | Tokenise | `pm_...` payment method id |
+| Braintree | `ccbraintree` | Tokenise | `tokencc_...` nonce |
+| Shopify | `ccshopify` | Tokenise | card session id |
+| PayDock | `ccpaydock` | Tokenise | one-time card token |
+
+## Install
+
+```bash
+pip install ccencrypt
+```
+
+## Card details
+
+Every function cleans the card details before using them, so any of these work:
+
+| Field | Accepted |
+|---|---|
+| card | `"4242424242424242"`, `"4242 4242 4242 4242"`, `"4242-4242-4242-4242"` |
+| month | `1`, `"1"`, `"01"` |
+| year | `29`, `"29"`, `2029`, `"2029"` |
+
+Month and year are always separate arguments. If you have `"01/29"`, split it first:
+
+```python
+month, year = "01/29".split("/")
+```
+
+## Proxies
+
+You can pass a proxy for the process. Some processors like paydock will ratelimit so its important to use proxies:
+
+```python
+token = ccencrypt.ccpaydock(public_key, card, month, year, cvv, name, proxy="http://user:pass@host:port")
+```
+
+## Errors
+
+Tokenise functions raise `RuntimeError` with the status code and response body when the processor rejects the request.
+
+---
+
+## Encryption
+
+### Adyen
+
+`encrypt_key` is the site's Adyen public key (`10001|A532...`).
+
+```python
+import ccencrypt
+
+result = ccencrypt.ccadyen(
+    encrypt_key="10001|A532...",
+    card="4242424242424242",
+    month="12",
+    year="2029",
+    cvc="123",
+    client_key="live_...",
+    domain="https://example.com",
+)
+
+result["encryptedCardNumber"]
+result["encryptedExpiryMonth"]
+result["encryptedExpiryYear"]
+result["encryptedSecurityCode"]
+```
+
+`client_key` and `domain` are optional, but pass the site's own values when you have them.
+
+`version` defaults to `"4.5.0"` (Secured Fields). For sites on legacy encryption (`adyenjs_0_1_XX$...`), pass `"0_1_18"`, `"0_1_22"`, `"0_1_23"`, `"0_1_24"` or `"0_1_25"`. Legacy versions ignore `client_key` and `domain`.
+
+```python
+result = ccencrypt.ccadyen(encrypt_key, card, month, year, cvc, version="0_1_25")
+```
+
+To encrypt a custom legacy payload such as `holderName`:
+
+```python
+from ccencrypt.adyen import parse_public_key
+
+blob = ccencrypt.cse_encrypt(
+    {"holderName": "John Smith", "generationtime": "2029-01-01T00:00:00.000Z"},
+    parse_public_key("10001|A532..."),
+    version="0_1_25",
+)
+```
+
+### CyberSource Flex
+
+`context` is the capture context JWT from the site's CyberSource init endpoint.
+
+Encrypt and exchange for a transient token in one call:
+
+```python
+token = ccencrypt.cccybersource_token(
+    card="4242424242424242",
+    month="12",
+    year="2029",
+    cvv="123",
+    context=context,
+    origin="https://www.example.com",
+    user_agent="Mozilla/5.0 ...",
+)
+```
+
+For Microform sites, pass `microform=True` instead of `origin`.
+
+To encrypt only, use `cccybersource` with the same card arguments and `context`. It returns a JWE that you POST yourself to `https://flex.cybersource.com/flex/v2/tokens` as `application/jwt`.
+
+### eWay
+
+`encrypt_key` is the `data-eway-encrypt-key` value from the site's payment form.
+
+```python
+fields = ccencrypt.cceway_card(encrypt_key, card="4242424242424242", cvv="123")
+
+fields["EWAY_CARDNUMBER"]
+fields["EWAY_CARDCVN"]
+```
+
+To encrypt a single value, use `ccencrypt.cceway(encrypt_key, value)`.
+
+---
+
+## Tokenisation
+
+### Stripe
+
+`key` is the site's publishable key (`pk_live_...`), sent as `key=` in the site's requests to `api.stripe.com`.
+
+```python
+pm = ccencrypt.ccstripe(
+    key="pk_live_...",
+    card="4242424242424242",
+    month="12",
+    year="2029",
+    cvc="123",
+    name="John Smith",
+)
+```
+
+If the site's requests also send `_stripe_account=acct_...`, pass it as `account`.
+
+### Braintree
+
+`client_token` is the base64 client token the site hands to Braintree. A raw `authorizationFingerprint` also works.
+
+```python
+nonce = ccencrypt.ccbraintree(
+    client_token="eyJ2ZXJzaW9uIjoy...",
+    card="4242424242424242",
+    month="12",
+    year="2029",
+    cvv="123",
+    name="John Smith",
+)
+```
+
+### Shopify
+
+`domain` is the store's domain, without `https://` or `www.`.
+
+```python
+session_id = ccencrypt.ccshopify(
+    domain="example.com.au",
+    card="4242424242424242",
+    month="12",
+    year="2029",
+    cvv="123",
+    name="John Smith",
+)
+```
+
+The returned id goes into the checkout's payment as the card `sessionId`.
+
+### PayDock
+
+`public_key` is the site's PayDock public key, sent as `x-user-public-key` in the site's requests to `api.paydock.com`.
+
+```python
+token = ccencrypt.ccpaydock(
+    public_key="5b12b8af...",
+    card="4242424242424242",
+    month="12",
+    year="2029",
+    cvv="123",
+    name="John Smith",
+)
+```
+
+If the site's token request includes a `gateway_id`, pass it as `gateway_id`.

ccencrypt-0.3.0/CCencrypt.egg-info/SOURCES.txt

@@ -0,0 +1,19 @@
+README.md
+pyproject.toml
+CCencrypt.egg-info/PKG-INFO
+CCencrypt.egg-info/SOURCES.txt
+CCencrypt.egg-info/dependency_links.txt
+CCencrypt.egg-info/requires.txt
+CCencrypt.egg-info/top_level.txt
+ccencrypt/__init__.py
+ccencrypt/adyen.py
+ccencrypt/adyen_cse.py
+ccencrypt/braintree.py
+ccencrypt/cybersource.py
+ccencrypt/eway.py
+ccencrypt/paydock.py
+ccencrypt/shopify.py
+ccencrypt/stripe.py
+ccencrypt/helpers/__init__.py
+ccencrypt/helpers/card.py
+ccencrypt/helpers/encoding.py

ccencrypt-0.3.0/CCencrypt.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

ccencrypt-0.3.0/CCencrypt.egg-info/requires.txt

@@ -0,0 +1,2 @@
+cryptography>=42.0.0
+requests>=2.28.0

ccencrypt-0.3.0/CCencrypt.egg-info/top_level.txt

@@ -0,0 +1 @@
+ccencrypt

ccencrypt-0.3.0/PKG-INFO

@@ -0,0 +1,214 @@
+Metadata-Version: 2.4
+Name: CCencrypt
+Version: 0.3.0
+Summary: Card encryption and tokenisation for Adyen, CyberSource, eWay, Stripe, Braintree, Shopify and PayDock
+Author: itsregza
+License: MIT
+Project-URL: Homepage, https://github.com/itsregza/CCencrypt
+Project-URL: Repository, https://github.com/itsregza/CCencrypt
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: cryptography>=42.0.0
+Requires-Dist: requests>=2.28.0
+
+<p align="center">
+  <img src="https://raw.githubusercontent.com/itsregza/CCencrypt/main/assets/banner.svg" alt="CCencrypt" width="520">
+</p>
+
+<p align="center">Card encryption and tokenisation for Python.</p>
+
+| Processor | Function | Type | Returns |
+|---|---|---|---|
+| Adyen | `ccadyen` | Encrypt | dict of 4 encrypted fields |
+| CyberSource Flex | `cccybersource` / `cccybersource_token` | Encrypt / Tokenise | JWE / transient token |
+| eWay | `cceway` / `cceway_card` | Encrypt | `eCrypted:...` strings |
+| Stripe | `ccstripe` | Tokenise | `pm_...` payment method id |
+| Braintree | `ccbraintree` | Tokenise | `tokencc_...` nonce |
+| Shopify | `ccshopify` | Tokenise | card session id |
+| PayDock | `ccpaydock` | Tokenise | one-time card token |
+
+## Install
+
+```bash
+pip install ccencrypt
+```
+
+## Card details
+
+Every function cleans the card details before using them, so any of these work:
+
+| Field | Accepted |
+|---|---|
+| card | `"4242424242424242"`, `"4242 4242 4242 4242"`, `"4242-4242-4242-4242"` |
+| month | `1`, `"1"`, `"01"` |
+| year | `29`, `"29"`, `2029`, `"2029"` |
+
+Month and year are always separate arguments. If you have `"01/29"`, split it first:
+
+```python
+month, year = "01/29".split("/")
+```
+
+## Proxies
+
+You can pass a proxy for the process. Some processors like paydock will ratelimit so its important to use proxies:
+
+```python
+token = ccencrypt.ccpaydock(public_key, card, month, year, cvv, name, proxy="http://user:pass@host:port")
+```
+
+## Errors
+
+Tokenise functions raise `RuntimeError` with the status code and response body when the processor rejects the request.
+
+---
+
+## Encryption
+
+### Adyen
+
+`encrypt_key` is the site's Adyen public key (`10001|A532...`).
+
+```python
+import ccencrypt
+
+result = ccencrypt.ccadyen(
+    encrypt_key="10001|A532...",
+    card="4242424242424242",
+    month="12",
+    year="2029",
+    cvc="123",
+    client_key="live_...",
+    domain="https://example.com",
+)
+
+result["encryptedCardNumber"]
+result["encryptedExpiryMonth"]
+result["encryptedExpiryYear"]
+result["encryptedSecurityCode"]
+```
+
+`client_key` and `domain` are optional, but pass the site's own values when you have them.
+
+`version` defaults to `"4.5.0"` (Secured Fields). For sites on legacy encryption (`adyenjs_0_1_XX$...`), pass `"0_1_18"`, `"0_1_22"`, `"0_1_23"`, `"0_1_24"` or `"0_1_25"`. Legacy versions ignore `client_key` and `domain`.
+
+```python
+result = ccencrypt.ccadyen(encrypt_key, card, month, year, cvc, version="0_1_25")
+```
+
+To encrypt a custom legacy payload such as `holderName`:
+
+```python
+from ccencrypt.adyen import parse_public_key
+
+blob = ccencrypt.cse_encrypt(
+    {"holderName": "John Smith", "generationtime": "2029-01-01T00:00:00.000Z"},
+    parse_public_key("10001|A532..."),
+    version="0_1_25",
+)
+```
+
+### CyberSource Flex
+
+`context` is the capture context JWT from the site's CyberSource init endpoint.
+
+Encrypt and exchange for a transient token in one call:
+
+```python
+token = ccencrypt.cccybersource_token(
+    card="4242424242424242",
+    month="12",
+    year="2029",
+    cvv="123",
+    context=context,
+    origin="https://www.example.com",
+    user_agent="Mozilla/5.0 ...",
+)
+```
+
+For Microform sites, pass `microform=True` instead of `origin`.
+
+To encrypt only, use `cccybersource` with the same card arguments and `context`. It returns a JWE that you POST yourself to `https://flex.cybersource.com/flex/v2/tokens` as `application/jwt`.
+
+### eWay
+
+`encrypt_key` is the `data-eway-encrypt-key` value from the site's payment form.
+
+```python
+fields = ccencrypt.cceway_card(encrypt_key, card="4242424242424242", cvv="123")
+
+fields["EWAY_CARDNUMBER"]
+fields["EWAY_CARDCVN"]
+```
+
+To encrypt a single value, use `ccencrypt.cceway(encrypt_key, value)`.
+
+---
+
+## Tokenisation
+
+### Stripe
+
+`key` is the site's publishable key (`pk_live_...`), sent as `key=` in the site's requests to `api.stripe.com`.
+
+```python
+pm = ccencrypt.ccstripe(
+    key="pk_live_...",
+    card="4242424242424242",
+    month="12",
+    year="2029",
+    cvc="123",
+    name="John Smith",
+)
+```
+
+If the site's requests also send `_stripe_account=acct_...`, pass it as `account`.
+
+### Braintree
+
+`client_token` is the base64 client token the site hands to Braintree. A raw `authorizationFingerprint` also works.
+
+```python
+nonce = ccencrypt.ccbraintree(
+    client_token="eyJ2ZXJzaW9uIjoy...",
+    card="4242424242424242",
+    month="12",
+    year="2029",
+    cvv="123",
+    name="John Smith",
+)
+```
+
+### Shopify
+
+`domain` is the store's domain, without `https://` or `www.`.
+
+```python
+session_id = ccencrypt.ccshopify(
+    domain="example.com.au",
+    card="4242424242424242",
+    month="12",
+    year="2029",
+    cvv="123",
+    name="John Smith",
+)
+```
+
+The returned id goes into the checkout's payment as the card `sessionId`.
+
+### PayDock
+
+`public_key` is the site's PayDock public key, sent as `x-user-public-key` in the site's requests to `api.paydock.com`.
+
+```python
+token = ccencrypt.ccpaydock(
+    public_key="5b12b8af...",
+    card="4242424242424242",
+    month="12",
+    year="2029",
+    cvv="123",
+    name="John Smith",
+)
+```
+
+If the site's token request includes a `gateway_id`, pass it as `gateway_id`.

ccencrypt-0.3.0/README.md

@@ -0,0 +1,201 @@
+<p align="center">
+  <img src="https://raw.githubusercontent.com/itsregza/CCencrypt/main/assets/banner.svg" alt="CCencrypt" width="520">
+</p>
+
+<p align="center">Card encryption and tokenisation for Python.</p>
+
+| Processor | Function | Type | Returns |
+|---|---|---|---|
+| Adyen | `ccadyen` | Encrypt | dict of 4 encrypted fields |
+| CyberSource Flex | `cccybersource` / `cccybersource_token` | Encrypt / Tokenise | JWE / transient token |
+| eWay | `cceway` / `cceway_card` | Encrypt | `eCrypted:...` strings |
+| Stripe | `ccstripe` | Tokenise | `pm_...` payment method id |
+| Braintree | `ccbraintree` | Tokenise | `tokencc_...` nonce |
+| Shopify | `ccshopify` | Tokenise | card session id |
+| PayDock | `ccpaydock` | Tokenise | one-time card token |
+
+## Install
+
+```bash
+pip install ccencrypt
+```
+
+## Card details
+
+Every function cleans the card details before using them, so any of these work:
+
+| Field | Accepted |
+|---|---|
+| card | `"4242424242424242"`, `"4242 4242 4242 4242"`, `"4242-4242-4242-4242"` |
+| month | `1`, `"1"`, `"01"` |
+| year | `29`, `"29"`, `2029`, `"2029"` |
+
+Month and year are always separate arguments. If you have `"01/29"`, split it first:
+
+```python
+month, year = "01/29".split("/")
+```
+
+## Proxies
+
+You can pass a proxy for the process. Some processors like paydock will ratelimit so its important to use proxies:
+
+```python
+token = ccencrypt.ccpaydock(public_key, card, month, year, cvv, name, proxy="http://user:pass@host:port")
+```
+
+## Errors
+
+Tokenise functions raise `RuntimeError` with the status code and response body when the processor rejects the request.
+
+---
+
+## Encryption
+
+### Adyen
+
+`encrypt_key` is the site's Adyen public key (`10001|A532...`).
+
+```python
+import ccencrypt
+
+result = ccencrypt.ccadyen(
+    encrypt_key="10001|A532...",
+    card="4242424242424242",
+    month="12",
+    year="2029",
+    cvc="123",
+    client_key="live_...",
+    domain="https://example.com",
+)
+
+result["encryptedCardNumber"]
+result["encryptedExpiryMonth"]
+result["encryptedExpiryYear"]
+result["encryptedSecurityCode"]
+```
+
+`client_key` and `domain` are optional, but pass the site's own values when you have them.
+
+`version` defaults to `"4.5.0"` (Secured Fields). For sites on legacy encryption (`adyenjs_0_1_XX$...`), pass `"0_1_18"`, `"0_1_22"`, `"0_1_23"`, `"0_1_24"` or `"0_1_25"`. Legacy versions ignore `client_key` and `domain`.
+
+```python
+result = ccencrypt.ccadyen(encrypt_key, card, month, year, cvc, version="0_1_25")
+```
+
+To encrypt a custom legacy payload such as `holderName`:
+
+```python
+from ccencrypt.adyen import parse_public_key
+
+blob = ccencrypt.cse_encrypt(
+    {"holderName": "John Smith", "generationtime": "2029-01-01T00:00:00.000Z"},
+    parse_public_key("10001|A532..."),
+    version="0_1_25",
+)
+```
+
+### CyberSource Flex
+
+`context` is the capture context JWT from the site's CyberSource init endpoint.
+
+Encrypt and exchange for a transient token in one call:
+
+```python
+token = ccencrypt.cccybersource_token(
+    card="4242424242424242",
+    month="12",
+    year="2029",
+    cvv="123",
+    context=context,
+    origin="https://www.example.com",
+    user_agent="Mozilla/5.0 ...",
+)
+```
+
+For Microform sites, pass `microform=True` instead of `origin`.
+
+To encrypt only, use `cccybersource` with the same card arguments and `context`. It returns a JWE that you POST yourself to `https://flex.cybersource.com/flex/v2/tokens` as `application/jwt`.
+
+### eWay
+
+`encrypt_key` is the `data-eway-encrypt-key` value from the site's payment form.
+
+```python
+fields = ccencrypt.cceway_card(encrypt_key, card="4242424242424242", cvv="123")
+
+fields["EWAY_CARDNUMBER"]
+fields["EWAY_CARDCVN"]
+```
+
+To encrypt a single value, use `ccencrypt.cceway(encrypt_key, value)`.
+
+---
+
+## Tokenisation
+
+### Stripe
+
+`key` is the site's publishable key (`pk_live_...`), sent as `key=` in the site's requests to `api.stripe.com`.
+
+```python
+pm = ccencrypt.ccstripe(
+    key="pk_live_...",
+    card="4242424242424242",
+    month="12",
+    year="2029",
+    cvc="123",
+    name="John Smith",
+)
+```
+
+If the site's requests also send `_stripe_account=acct_...`, pass it as `account`.
+
+### Braintree
+
+`client_token` is the base64 client token the site hands to Braintree. A raw `authorizationFingerprint` also works.
+
+```python
+nonce = ccencrypt.ccbraintree(
+    client_token="eyJ2ZXJzaW9uIjoy...",
+    card="4242424242424242",
+    month="12",
+    year="2029",
+    cvv="123",
+    name="John Smith",
+)
+```
+
+### Shopify
+
+`domain` is the store's domain, without `https://` or `www.`.
+
+```python
+session_id = ccencrypt.ccshopify(
+    domain="example.com.au",
+    card="4242424242424242",
+    month="12",
+    year="2029",
+    cvv="123",
+    name="John Smith",
+)
+```
+
+The returned id goes into the checkout's payment as the card `sessionId`.
+
+### PayDock
+
+`public_key` is the site's PayDock public key, sent as `x-user-public-key` in the site's requests to `api.paydock.com`.
+
+```python
+token = ccencrypt.ccpaydock(
+    public_key="5b12b8af...",
+    card="4242424242424242",
+    month="12",
+    year="2029",
+    cvv="123",
+    name="John Smith",
+)
+```
+
+If the site's token request includes a `gateway_id`, pass it as `gateway_id`.

ccencrypt-0.3.0/ccencrypt/__init__.py

@@ -0,0 +1,25 @@
+from ccencrypt.adyen import ccadyen, ccadyen_cse
+from ccencrypt.adyen_cse import CSE_VERSIONS, cse_encrypt
+from ccencrypt.braintree import ccbraintree
+from ccencrypt.cybersource import CardTypes, card_type, cccybersource, cccybersource_token
+from ccencrypt.eway import cceway, cceway_card
+from ccencrypt.paydock import ccpaydock
+from ccencrypt.shopify import ccshopify
+from ccencrypt.stripe import ccstripe
+
+__all__ = [
+    "ccadyen",
+    "ccadyen_cse",
+    "cse_encrypt",
+    "CSE_VERSIONS",
+    "cccybersource",
+    "cccybersource_token",
+    "cceway",
+    "cceway_card",
+    "ccstripe",
+    "ccbraintree",
+    "ccshopify",
+    "ccpaydock",
+    "CardTypes",
+    "card_type",
+]

ccencrypt-0.3.0/ccencrypt/adyen.py

@@ -0,0 +1,154 @@
+import base64
+import json
+import os
+from datetime import datetime, timezone
+
+from cryptography.hazmat.backends import default_backend
+from cryptography.hazmat.primitives import hashes, hmac
+from cryptography.hazmat.primitives.asymmetric import padding, rsa
+from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
+
+from ccencrypt.adyen_cse import cse_encrypt
+from ccencrypt.helpers.card import clean_card, expiry
+from ccencrypt.helpers.encoding import b64url, hex_to_bytes, pack_bit_length
+
+OAEP = padding.OAEP(
+    mgf=padding.MGF1(algorithm=hashes.SHA1()),
+    algorithm=hashes.SHA1(),
+    label=None,
+)
+
+
+def utc_stamp():
+    dt = datetime.now(timezone.utc)
+    return dt.strftime("%Y-%m-%dT%H:%M:%S.") + f"{int(dt.microsecond / 1000):03d}Z"
+
+
+def parse_public_key(encrypt_key):
+    parts = encrypt_key.split("|", 1)
+    if len(parts) != 2:
+        raise ValueError("malformed encrypt key")
+    e = int.from_bytes(hex_to_bytes(parts[0]), "big")
+    n = int.from_bytes(hex_to_bytes(parts[1]), "big")
+    return rsa.RSAPublicNumbers(e, n).public_key(default_backend())
+
+
+def jwe_encrypt(payload, public_key):
+    dek = os.urandom(64)
+    wrapped_key = public_key.encrypt(dek, OAEP)
+
+    header_json = json.dumps(
+        {"alg": "RSA-OAEP", "enc": "A256CBC-HS512", "version": "1"},
+        separators=(",", ":"),
+    )
+    header_b64 = b64url(header_json.encode("utf-8"))
+    header_raw = header_b64.encode("utf-8")
+
+    iv = os.urandom(16)
+    body = json.dumps(payload, separators=(",", ":")).encode("utf-8")
+    pad = 16 - (len(body) % 16)
+    body = body + bytes([pad]) * pad
+
+    enc = Cipher(algorithms.AES(dek[32:]), modes.CBC(iv), backend=default_backend()).encryptor()
+    ciphertext = enc.update(body) + enc.finalize()
+
+    mac = hmac.HMAC(dek[:32], hashes.SHA512(), backend=default_backend())
+    mac.update(header_raw + iv + ciphertext + pack_bit_length(len(header_raw)))
+    auth_tag = mac.finalize()[:32]
+
+    return ".".join([header_b64, b64url(wrapped_key), b64url(iv), b64url(ciphertext), b64url(auth_tag)])
+
+
+def secured_fields_referrer(client_key, domain):
+    d = base64.b64encode(domain.encode("utf-8")).decode("ascii")
+    return (
+        "https://checkoutshopper-live.adyen.com/checkoutshopper/securedfields/"
+        f"{client_key}/4.5.0/securedFields.html?type=card&d={d}"
+    )
+
+
+def format_pan(card):
+    digits = clean_card(card)
+    return " ".join(digits[i : i + 4] for i in range(0, len(digits), 4))
+
+
+def build_card_payloads(card, month, year, cvc, referrer, ts):
+    pan = format_pan(card)
+    month, year = expiry(month, year)
+    cvc = str(cvc)
+    return {
+        "encryptedCardNumber": {
+            "number": pan,
+            "generationtime": ts,
+            "numberBind": "1",
+            "activate": "3",
+            "referrer": referrer,
+            "numberFieldFocusCount": "3",
+            "numberFieldLog": "fo@44070,cl@44071,KN@44082,fo@44324,cl@44325,cl@44333,KN@44346,KN@44347,KN@44348,KN@44350,KN@44351,KN@44353,KN@44354,KN@44355,KN@44356,KN@44358,fo@44431,cl@44432,KN@44434,KN@44436,KN@44438,KN@44440,KN@44440",
+            "numberFieldClickCount": "4",
+            "numberFieldKeyCount": "16",
+        },
+        "encryptedExpiryMonth": {"expiryMonth": month, "generationtime": ts},
+        "encryptedExpiryYear": {"expiryYear": year, "generationtime": ts},
+        "encryptedSecurityCode": {
+            "cvc": cvc,
+            "generationtime": ts,
+            "cvcBind": "1",
+            "activate": "4",
+            "referrer": referrer,
+            "cvcFieldFocusCount": "4",
+            "cvcFieldLog": "fo@122,cl@123,KN@136,KN@138,KN@140,fo@11204,cl@11205,ch@11221,bl@11221,fo@33384,bl@33384,fo@50318,cl@50319,cl@50321,KN@50334,KN@50336,KN@50336",
+            "cvcFieldClickCount": "4",
+            "cvcFieldKeyCount": "6",
+            "cvcFieldChangeCount": "1",
+            "cvcFieldBlurCount": "2",
+            "deactivate": "2",
+        },
+    }
+
+
+def ccadyen(
+    encrypt_key,
+    card,
+    month,
+    year,
+    cvc,
+    client_key=None,
+    domain=None,
+    version="4.5.0",
+):
+    if not card or not month or not year or not cvc:
+        raise ValueError("missing card details")
+    if not encrypt_key:
+        raise ValueError("missing encrypt key")
+    if str(version).strip() != "4.5.0":
+        return ccadyen_cse(encrypt_key, card, month, year, cvc, version=version)
+    if not client_key:
+        client_key = "live_SQV7J3WVMNFK3HU33BTUNF5AH4E2L2ZN"
+    if not domain:
+        domain = "https://minisoshop.co.uk"
+
+    rsa_key = parse_public_key(encrypt_key)
+    referrer = secured_fields_referrer(client_key, domain)
+    ts = utc_stamp()
+    fields = build_card_payloads(card, month, year, cvc, referrer, ts)
+
+    return {name: jwe_encrypt(data, rsa_key) for name, data in fields.items()}
+
+
+def ccadyen_cse(encrypt_key, card, month, year, cvc, version="0_1_25"):
+    if not card or not month or not year or not cvc:
+        raise ValueError("missing card details")
+    if not encrypt_key:
+        raise ValueError("missing encrypt key")
+
+    rsa_key = parse_public_key(encrypt_key)
+    ts = utc_stamp()
+    month, year = expiry(month, year)
+    fields = {
+        "encryptedCardNumber": {"number": format_pan(card), "generationtime": ts},
+        "encryptedExpiryMonth": {"expiryMonth": month, "generationtime": ts},
+        "encryptedExpiryYear": {"expiryYear": year, "generationtime": ts},
+        "encryptedSecurityCode": {"cvc": str(cvc), "generationtime": ts},
+    }
+    return {name: cse_encrypt(data, rsa_key, version) for name, data in fields.items()}

ccencrypt-0.3.0/ccencrypt/adyen_cse.py

@@ -0,0 +1,45 @@
+import base64
+import json
+import os
+
+from cryptography.hazmat.primitives.asymmetric import padding
+from cryptography.hazmat.primitives.ciphers.aead import AESCCM
+
+CSE_VERSIONS = ("0_1_18", "0_1_22", "0_1_23", "0_1_24", "0_1_25")
+
+
+def normalize_cse_version(version):
+    v = str(version).strip().lower().replace("adyenjs_", "").replace(".", "_")
+    if v.isdigit():
+        v = f"0_1_{v}"
+    if v not in CSE_VERSIONS:
+        raise ValueError(f"unsupported adyen cse version: {version!r}")
+    return v
+
+
+def cse_extra_fields(version):
+    # Fields the adyen-encrypt JS lib appends to every payload for this version.
+    if version == "0_1_18":
+        return {"initializeCount": "1", "dfValue": ""}
+    if version == "0_1_25":
+        return {"initializeCount": "1", "sjclStrength": "10"}
+    return {"initializeCount": "1", "sjclStrength": "10", "dfValue": ""}
+
+
+def cse_encrypt(data, public_key, version="0_1_25"):
+    version = normalize_cse_version(version)
+    payload = dict(data)
+    payload.update(cse_extra_fields(version))
+    plaintext = json.dumps(payload, separators=(",", ":")).encode("utf-8")
+
+    aes_key = os.urandom(32)
+    iv = os.urandom(12)
+    cipher = AESCCM(aes_key, tag_length=8).encrypt(iv, plaintext, None)
+    wrapped_key = public_key.encrypt(aes_key, padding.PKCS1v15())
+
+    return "".join([
+        f"adyenjs_{version}$",
+        base64.b64encode(wrapped_key).decode("ascii"),
+        "$",
+        base64.b64encode(iv + cipher).decode("ascii"),
+    ])

ccencrypt-0.3.0/ccencrypt/braintree.py

@@ -0,0 +1,66 @@
+import base64
+import json
+import uuid
+
+import requests
+
+from ccencrypt.helpers.card import clean_card, expiry, proxies
+
+BRAINTREE_GQL_URL = "https://payments.braintree-api.com/graphql"
+
+TOKENIZE_QUERY = (
+    "mutation TokenizeCreditCard($input: TokenizeCreditCardInput!) { "
+    "tokenizeCreditCard(input: $input) { token creditCard { bin brandCode last4 } } }"
+)
+
+
+def fingerprint(client_token):
+    try:
+        data = json.loads(base64.b64decode(client_token))
+    except Exception:
+        return client_token
+    return data["authorizationFingerprint"]
+
+
+def ccbraintree(client_token, card, month, year, cvv, name="", proxy=None, timeout=30):
+    month, year = expiry(month, year)
+    payload = {
+        "clientSdkMetadata": {
+            "source": "client",
+            "integration": "custom",
+            "sessionId": str(uuid.uuid4()),
+        },
+        "query": TOKENIZE_QUERY,
+        "variables": {
+            "input": {
+                "creditCard": {
+                    "number": clean_card(card),
+                    "expirationMonth": month,
+                    "expirationYear": year,
+                    "cvv": str(cvv).strip(),
+                    "cardholderName": name,
+                },
+                "options": {"validate": False},
+            }
+        },
+        "operationName": "TokenizeCreditCard",
+    }
+
+    resp = requests.post(
+        BRAINTREE_GQL_URL,
+        headers={
+            "authorization": f"Bearer {fingerprint(client_token)}",
+            "braintree-version": "2018-05-10",
+            "content-type": "application/json",
+            "origin": "https://assets.braintreegateway.com",
+            "referer": "https://assets.braintreegateway.com/",
+        },
+        json=payload,
+        proxies=proxies(proxy),
+        timeout=timeout,
+    )
+    body = resp.json() if resp.text else {}
+    token = ((body.get("data") or {}).get("tokenizeCreditCard") or {}).get("token")
+    if resp.status_code != 200 or not token:
+        raise RuntimeError(f"braintree failed: {resp.status_code} {resp.text[:300]}")
+    return token

ccencrypt-0.3.0/ccencrypt/cybersource.py

@@ -0,0 +1,150 @@
+import json
+import os
+import urllib.parse
+
+import requests
+
+from cryptography.hazmat.backends import default_backend
+from cryptography.hazmat.primitives import hashes
+from cryptography.hazmat.primitives.asymmetric import padding, rsa
+from cryptography.hazmat.primitives.ciphers.aead import AESGCM
+
+from ccencrypt.helpers.card import clean_card, expiry, proxies
+from ccencrypt.helpers.encoding import b64url, b64url_decode, jwt_payload
+
+FLEX_TOKENS_URL = "https://flex.cybersource.com/flex/v2/tokens"
+
+
+CardTypes = {
+    "Visa": "001",
+    "MasterCard": "002",
+    "AmericanExpress": "003",
+    "Discover": "004",
+    "Diners": "005",
+    "JCB": "007",
+    "Maestro": "042",
+    "ChinaUnionPay": "062",
+}
+
+
+def card_type(number):
+    n = clean_card(number)
+    if n.startswith("5"):
+        return CardTypes["MasterCard"]
+    if n.startswith("34") or n.startswith("37"):
+        return CardTypes["AmericanExpress"]
+    return CardTypes["Visa"]
+
+
+def jwk_rsa_key(jwk):
+    e = int.from_bytes(b64url_decode(jwk["e"]), "big")
+    n = int.from_bytes(b64url_decode(jwk["n"]), "big")
+    return rsa.RSAPublicNumbers(e, n).public_key(default_backend())
+
+
+def cccybersource(card, month, year, cvv, context, index=0):
+    key_id = jwt_payload(context)
+    jwk = key_id["flx"]["jwk"]
+    header = {
+        "kid": jwk["kid"],
+        "alg": "RSA-OAEP",
+        "enc": "A256GCM",
+    }
+    month, year = expiry(month, year)
+    payload = {
+        "data": {
+            "number": clean_card(card),
+            "securityCode": str(cvv),
+            "expirationMonth": month,
+            "expirationYear": year,
+            "type": card_type(card),
+        },
+        "context": context,
+        "index": index,
+    }
+
+    iv = os.urandom(12)
+    aes_key = AESGCM.generate_key(bit_length=256)
+    header_b64 = b64url(json.dumps(header, separators=(",", ":")))
+    aad = header_b64.encode("utf-8")
+    plaintext = json.dumps(payload, separators=(",", ":")).encode("utf-8")
+    encrypted = AESGCM(aes_key).encrypt(iv, plaintext, aad)
+
+    tag_len = 16
+    body = encrypted[:-tag_len]
+    tag = encrypted[-tag_len:]
+
+    wrapped = jwk_rsa_key(jwk).encrypt(
+        aes_key,
+        padding.OAEP(
+            mgf=padding.MGF1(algorithm=hashes.SHA1()),
+            algorithm=hashes.SHA1(),
+            label=None,
+        ),
+    )
+
+    return ".".join(
+        [
+            header_b64,
+            b64url(wrapped),
+            b64url(iv),
+            b64url(body),
+            b64url(tag),
+        ]
+    )
+
+
+def microform_referer(context):
+    kid = jwt_payload(context)["flx"]["jwk"]["kid"]
+    q = urllib.parse.quote(kid, safe="")
+    return f"https://flex.cybersource.com/microform/bundle/v2.9.0/iframe.html?keyId={q}"
+
+
+def cccybersource_token(
+    card,
+    month,
+    year,
+    cvv,
+    context,
+    origin=None,
+    referer=None,
+    user_agent=None,
+    microform=False,
+    index=0,
+    proxy=None,
+    timeout=30,
+):
+    encrypted = cccybersource(card, month, year, cvv, context, index=index)
+
+    if microform:
+        headers = {
+            "content-type": "application/jwt; charset=UTF-8",
+            "origin": "https://flex.cybersource.com",
+            "referer": referer or microform_referer(context),
+        }
+    else:
+        if not origin:
+            raise ValueError("origin required unless microform=True")
+        site = origin.rstrip("/")
+        headers = {
+            "content-type": "application/jwt",
+            "origin": site,
+            "referer": referer or f"{site}/",
+        }
+
+    if user_agent:
+        headers["user-agent"] = user_agent
+
+    resp = requests.post(
+        FLEX_TOKENS_URL,
+        headers=headers,
+        data=str(encrypted).strip(),
+        proxies=proxies(proxy),
+        timeout=timeout,
+    )
+    if resp.status_code != 201:
+        raise RuntimeError(f"flex /tokens failed: {resp.status_code} {(resp.text or '')[:300]}")
+    token = (resp.text or "").strip()
+    if not token:
+        raise RuntimeError("flex /tokens returned empty body")
+    return token

ccencrypt-0.3.0/ccencrypt/eway.py

@@ -0,0 +1,35 @@
+import base64
+
+from cryptography.hazmat.backends import default_backend
+from cryptography.hazmat.primitives.asymmetric import padding, rsa
+
+from ccencrypt.helpers.card import clean_card
+
+
+def modulus_from_key_blob(key_blob):
+    try:
+        mod_bytes = base64.b64decode(key_blob)
+    except Exception as exc:
+        raise ValueError("invalid encrypt key") from exc
+    n = int.from_bytes(mod_bytes, "big")
+    return rsa.RSAPublicNumbers(65537, n).public_key(default_backend())
+
+
+def cceway(encrypt_key, value):
+    if not encrypt_key:
+        raise ValueError("missing encrypt key")
+    if value is None or str(value).strip() == "":
+        raise ValueError("missing value")
+
+    pub = modulus_from_key_blob(str(encrypt_key).strip())
+    ciphertext = pub.encrypt(str(value).encode("utf-8"), padding.PKCS1v15())
+    return "eCrypted:" + base64.b64encode(ciphertext).decode("ascii")
+
+
+def cceway_card(encrypt_key, card, cvv):
+    pan = clean_card(card)
+    code = str(cvv).strip()
+    return {
+        "EWAY_CARDNUMBER": cceway(encrypt_key, pan),
+        "EWAY_CARDCVN": cceway(encrypt_key, code),
+    }

ccencrypt-0.3.0/ccencrypt/helpers/card.py

@@ -0,0 +1,21 @@
+def clean_card(card):
+    return str(card).strip().replace(" ", "").replace("-", "")
+
+
+def spaced_card(card):
+    n = clean_card(card)
+    if len(n) == 15:
+        return f"{n[:4]} {n[4:10]} {n[10:]}"
+    return " ".join(n[i : i + 4] for i in range(0, len(n), 4))
+
+
+def proxies(proxy):
+    return {"http": proxy, "https": proxy} if proxy else None
+
+
+def expiry(month, year):
+    m = "".join(c for c in str(month) if c.isdigit()).zfill(2)[-2:]
+    y = "".join(c for c in str(year) if c.isdigit())
+    if len(y) == 2:
+        y = "20" + y
+    return m, y

ccencrypt-0.3.0/ccencrypt/helpers/encoding.py

@@ -0,0 +1,34 @@
+import base64
+import json
+
+
+def b64url(data):
+    if isinstance(data, str):
+        data = data.encode("utf-8")
+    return base64.b64encode(data).decode("ascii").rstrip("=").replace("+", "-").replace("/", "_")
+
+
+def hex_to_bytes(hex_str):
+    if not hex_str:
+        return b""
+    if len(hex_str) % 2 == 1:
+        hex_str = "0" + hex_str
+    return bytes.fromhex(hex_str)
+
+
+def b64url_decode(s):
+    s = s.replace("-", "+").replace("_", "/")
+    pad = "=" * ((4 - len(s) % 4) % 4)
+    return base64.b64decode(s + pad)
+
+
+def jwt_payload(token):
+    part = token.split(".")[1]
+    return json.loads(b64url_decode(part))
+
+
+def pack_bit_length(length_bytes):
+    bits = length_bytes * 8
+    hi = bits // (2**32)
+    lo = bits % (2**32)
+    return hi.to_bytes(4, "big") + lo.to_bytes(4, "big")

ccencrypt-0.3.0/ccencrypt/paydock.py

@@ -0,0 +1,41 @@
+import requests
+
+from ccencrypt.helpers.card import clean_card, expiry, proxies
+
+PAYDOCK_TOKENS_URL = "https://api.paydock.com/v1/payment_sources/tokens"
+
+
+def ccpaydock(public_key, card, month, year, cvv, name, gateway_id="", proxy=None, timeout=30):
+    month, year = expiry(month, year)
+    payload = {
+        "type": "card",
+        "card_name": name,
+        "card_number": clean_card(card),
+        "expire_month": month,
+        "expire_year": year[-2:],
+        "card_ccv": str(cvv).strip(),
+        "gateway_id": gateway_id,
+        "store_ccv": True,
+        "meta": {},
+    }
+
+    resp = requests.post(
+        PAYDOCK_TOKENS_URL,
+        headers={
+            "accept": "application/json, text/plain, */*",
+            "content-type": "application/json",
+            "origin": "https://widget.paydock.com",
+            "referer": "https://widget.paydock.com/",
+            "x-sdk-type": "client",
+            "x-sdk-version": "v1.131.0",
+            "x-user-public-key": public_key,
+        },
+        json=payload,
+        proxies=proxies(proxy),
+        timeout=timeout,
+    )
+    body = resp.json() if resp.text else {}
+    token = (body.get("resource") or {}).get("data")
+    if resp.status_code != 201 or not token:
+        raise RuntimeError(f"paydock failed: {resp.status_code} {resp.text[:300]}")
+    return token

ccencrypt-0.3.0/ccencrypt/shopify.py

@@ -0,0 +1,40 @@
+import requests
+
+from ccencrypt.helpers.card import expiry, proxies, spaced_card
+
+SHOPIFY_PCI_URL = "https://checkout.pci.shopifyinc.com/sessions"
+
+
+def ccshopify(domain, card, month, year, cvv, name, proxy=None, timeout=30):
+    month, year = expiry(month, year)
+    payload = {
+        "credit_card": {
+            "number": spaced_card(card),
+            "month": int(month),
+            "year": int(year),
+            "verification_value": str(cvv).strip(),
+            "start_month": None,
+            "start_year": None,
+            "issue_number": "",
+            "name": name,
+        },
+        "payment_session_scope": domain.replace("https://", "").replace("www.", "").strip("/"),
+    }
+
+    resp = requests.post(
+        SHOPIFY_PCI_URL,
+        headers={
+            "accept": "application/json",
+            "content-type": "application/json",
+            "origin": "https://checkout.pci.shopifyinc.com",
+            "referer": "https://checkout.pci.shopifyinc.com/",
+        },
+        json=payload,
+        proxies=proxies(proxy),
+        timeout=timeout,
+    )
+    body = resp.json() if resp.text else {}
+    session_id = body.get("id")
+    if resp.status_code != 200 or not session_id:
+        raise RuntimeError(f"shopify failed: {resp.status_code} {resp.text[:300]}")
+    return session_id

ccencrypt-0.3.0/ccencrypt/stripe.py

@@ -0,0 +1,47 @@
+import uuid
+
+import requests
+
+from ccencrypt.helpers.card import clean_card, expiry, proxies
+
+STRIPE_PM_URL = "https://api.stripe.com/v1/payment_methods"
+STRIPE_JS = "stripe.js/e2a5fc9c3e; stripe-js-v3/e2a5fc9c3e; card-element"
+
+
+def ccstripe(key, card, month, year, cvc, name="", account=None, proxy=None, timeout=30):
+    month, year = expiry(month, year)
+    data = {
+        "type": "card",
+        "card[number]": clean_card(card),
+        "card[cvc]": str(cvc).strip(),
+        "card[exp_month]": month,
+        "card[exp_year]": year[-2:],
+        "payment_user_agent": STRIPE_JS,
+        "guid": str(uuid.uuid4()),
+        "muid": str(uuid.uuid4()),
+        "sid": str(uuid.uuid4()),
+        "key": key,
+    }
+    if name:
+        data["billing_details[name]"] = name
+    if account:
+        data["_stripe_account"] = account
+
+    resp = requests.post(
+        STRIPE_PM_URL,
+        headers={
+            "accept": "application/json",
+            "content-type": "application/x-www-form-urlencoded",
+            "origin": "https://js.stripe.com",
+            "referer": "https://js.stripe.com/",
+        },
+        data=data,
+        proxies=proxies(proxy),
+        timeout=timeout,
+    )
+    body = resp.json() if resp.text else {}
+    pm = body.get("id", "")
+    if resp.status_code != 200 or not pm.startswith("pm_"):
+        err = body.get("error") or {}
+        raise RuntimeError(f"stripe failed: {resp.status_code} {err.get('message') or resp.text[:300]}")
+    return pm

ccencrypt-0.3.0/pyproject.toml

@@ -0,0 +1,24 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "CCencrypt"
+version = "0.3.0"
+description = "Card encryption and tokenisation for Adyen, CyberSource, eWay, Stripe, Braintree, Shopify and PayDock"
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "MIT" }
+authors = [{ name = "itsregza" }]
+dependencies = [
+    "cryptography>=42.0.0",
+    "requests>=2.28.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/itsregza/CCencrypt"
+Repository = "https://github.com/itsregza/CCencrypt"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["ccencrypt*"]

ccencrypt-0.3.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+