esp-matter-mfg-tool 1.0.0__tar.gz

esp-matter-mfg-tool-1.0.0/MANIFEST.in

@@ -0,0 +1 @@
+include requirements.txt

esp-matter-mfg-tool-1.0.0/PKG-INFO

@@ -0,0 +1,50 @@
+Metadata-Version: 2.1
+Name: esp-matter-mfg-tool
+Version: 1.0.0
+Summary: A python utility which helps to generate matter manufacturing partitions
+Home-page: https://github.com/espressif/esp-matter-tools/tree/main/mfg_tool
+Author: Espressif Systems
+Author-email: 
+License: Apache-2.0
+Project-URL: Documentation, https://github.com/espressif/esp-matter-tools/tree/main/mfg_tool/README.md
+Project-URL: Source, https://github.com/espressif/esp-matter-tools/tree/main/mfg_tool
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Intended Audience :: Developers
+Classifier: Natural Language :: English
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Topic :: Software Development :: Embedded Systems
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.9
+Description-Content-Type: text/x-rst
+Requires-Dist: bitarray>=2.6.0
+Requires-Dist: cryptography==36.0.0
+Requires-Dist: cffi==1.15.0
+Requires-Dist: future==0.18.2
+Requires-Dist: pycparser==2.21
+Requires-Dist: pypng==0.0.21
+Requires-Dist: PyQRCode==1.2.1
+Requires-Dist: python_stdnum==1.18
+Requires-Dist: esp-secure-cert-tool==1.0.1
+Requires-Dist: ecdsa==0.18.0
+
+
+====================
+esp-matter-mfg-tool
+====================
+The python utility helps to generate the matter manufacturing partitions.
+
+Source code for `esp-matter-mfg-tool` is
+`hosted on github <https://github.com/espressif/esp-matter-tools/tree/main/mfg_tool>`_.
+
+Documentation
+-------------
+Visit online `esp-matter-mfg-tool documentation <https://github.com/espressif/esp-matter-tools/tree/main/mfg_tool>`_
+or run ``esp-matter-mfg-tool -h``.
+
+License
+-------
+The License for the project can be found
+`here <https://github.com/espressif/esp-matter-tools/tree/main/LICENSE>`_

esp-matter-mfg-tool-1.0.0/README.md

@@ -0,0 +1,251 @@
+# Matter Manufacturing Partitions Generator Utility
+
+esp-matter-mfg-tool helps generate the Matter compatible manufacturing and
+secure certificate partitions.
+
+Manufacturing partition can contain the Matter specific data as well as it
+supports adding custom manufacturer specific data using csv files.
+
+## How to install
+
+### Install using pip
+
+esp-matter-mfg-tool can be installed using package installer for Python
+
+```
+python3 -m pip install esp-matter-mfg-tool
+```
+
+### Optional dependency
+
+If you want to use the esp-matter-mfg-tool for signing DAC by providing PAI or PAA certificate and key, then chip-cert is required.
+
+[CHIP Certificate Tool](https://github.com/project-chip/connectedhomeip/tree/master/src/tools/chip-cert), *chip-cert*,
+provides command line interface (CLI) utility used for generating and manipulating CHIP certificates and CHIP private keys.
+
+If you have already setup the esp-matter and ran `install.sh` and sourced `export.sh` then you can skip building and adding tools to path steps.
+
+#### Build chip-cert
+```
+cd $ESP_MATTER_PATH/connectedhomeip/connectedhomeip
+source scripts/activate.sh
+gn gen out/host
+ninja -C out/host chip-cert
+```
+Above commands will generate chip-cert at `esp-matter/connectedhomeip/connectedhomeip/out/host`.
+
+#### Add the tools path to $PATH
+```
+export PATH="$PATH:$ESP_MATTER_PATH/connectedhomeip/connectedhomeip/out/host"
+```
+
+## Configure your app
+Open the project configuration menu using - 
+
+```
+cd <your_app>
+idf.py menuconfig
+```
+In the configuration menu, set the following additional configuration to use custom factory partition and different values for Data and Device Info Providers.
+
+1. Enable `ESP32 Factory Data Provider` [Component config → CHIP Device Layer → Commissioning options → Use ESP32 Factory Data Provider]
+
+    Enable config option [`CONFIG_ENABLE_ESP32_FACTORY_DATA_PROVIDER`](https://github.com/project-chip/connectedhomeip/blob/master/config/esp32/components/chip/Kconfig#L645)
+    to use ESP32 specific implementation of CommissionableDataProvider and DeviceAttestationCredentialsProvider.
+
+2. Enable `ESP32 Device Instance Info Provider` [Component config → CHIP Device Layer → Commissioning options → Use ESP32 Device Instance Info Provider]
+
+    Enable config option [`ENABLE_ESP32_DEVICE_INSTANCE_INFO_PROVIDER`](https://github.com/project-chip/connectedhomeip/blob/master/config/esp32/components/chip/Kconfig#L655)
+    to get device instance info from factory partition.
+
+3. Enable `Attestation - Factory` [ Component config → ESP Matter → DAC Provider options → Attestation - Factory]
+
+    Enable config option `CONFIG_FACTORY_PARTITION_DAC_PROVIDER` to use DAC certificates from the factory partition during Attestation.
+
+4. Set `chip-factory namespace partition label` [Component config → CHIP Device Layer → Matter Manufacturing Options → chip-factory namespace partition label]
+
+    Set config option [`CHIP_FACTORY_NAMESPACE_PARTITION_LABEL`](https://github.com/project-chip/connectedhomeip/blob/master/config/esp32/components/chip/Kconfig#L856)
+    to choose the label of the partition to store key-values in the "chip-factory" namespace. The default chosen partition label is `nvs`.
+
+## Output files and directory structure
+```
+out
+└── fff1_8000
+    ├── 11fe2c53-9a38-445c-b58f-2ff0554cd981
+    │   ├── 11fe2c53-9a38-445c-b58f-2ff0554cd981-onb_codes.csv
+    │   ├── 11fe2c53-9a38-445c-b58f-2ff0554cd981-partition.bin
+    │   ├── 11fe2c53-9a38-445c-b58f-2ff0554cd981-qrcode.png
+    │   └── internal
+    │       ├── DAC_cert.der
+    │       ├── DAC_cert.pem
+    │       ├── DAC_key.pem
+    │       ├── DAC_private_key.bin
+    │       ├── DAC_public_key.bin
+    │       ├── PAI_cert.der
+    │       └── partition.csv
+    ├── 14874525-30b5-4c66-a00e-30e4af5dfb20
+    │   ├── 14874525-30b5-4c66-a00e-30e4af5dfb20-onb_codes.csv
+    │   ├── 14874525-30b5-4c66-a00e-30e4af5dfb20-partition.bin
+    │   ├── 14874525-30b5-4c66-a00e-30e4af5dfb20-qrcode.png
+    │   └── internal
+    │       ├── DAC_cert.der
+    │       ├── DAC_cert.pem
+    │       ├── DAC_key.pem
+    │       ├── DAC_private_key.bin
+    │       ├── DAC_public_key.bin
+    │       ├── PAI_cert.der
+    │       └── partition.csv
+    └── staging
+        ├── config.csv
+        ├── master.csv
+        ├── pai_cert.der
+        └── pin_disc.csv
+```
+
+Tool generates following output files:
+- Partition Binary : `<uuid>-partition.bin`
+- Onboarding codes : `<uuid>-onb_codes.csv`
+- QR Code image    : `<uuid>-qrcode.png`
+
+Other intermediate files are stored in `internal/` directory:
+- Partition CSV    : `partition.csv`
+- PAI Certificate  : `PAI_cert.der`
+- DAC Certificates : `DAC_cert.der`, `DAC_cert.pem`
+- DAC Private Key  : `DAC_private_key.bin`
+- DAC Public Key   : `DAC_public_key.bin`
+
+Above files are stored at `out/<vid_pid>/<UUID>`. Each device is identified with an unique UUID.
+
+Common intermediate files are stored at `out/<vid_pid>/staging`.
+
+## Usage examples
+`esp-matter-mfg-tool -h` lists the options.
+
+Below commands uses the test PAI signing certificate and key, test certificate declaration present in Matter SDK, Vendor ID: 0xFFF2, and Product ID: 0x8001.
+
+Export the Matter SDK path to simplify the certificate and key paths.
+```
+export MATTER_SDK_PATH=$ESP_MATTER_PATH/connectedhomeip/connectedhomeip
+```
+
+### Generate a factory partition
+```
+esp-matter-mfg-tool -cn "My bulb" -v 0xFFF2 -p 0x8001 --pai \
+    -k $MATTER_SDK_PATH/credentials/test/attestation/Chip-Test-PAI-FFF2-8001-Key.pem \
+    -c $MATTER_SDK_PATH/credentials/test/attestation/Chip-Test-PAI-FFF2-8001-Cert.pem \
+    -cd $MATTER_SDK_PATH/credentials/test/certification-declaration/Chip-Test-CD-FFF2-8001.der
+```
+
+#### Generate a factory partition and store DAC certificate and private key in secure cert partition [Optional argument : `--dac-in-secure-cert` and `--target`]
+```
+esp-matter-mfg-tool -cn "My bulb" -v 0xFFF2 -p 0x8001 --pai \
+    -k $MATTER_SDK_PATH/credentials/test/attestation/Chip-Test-PAI-FFF2-8001-Key.pem \
+    -c $MATTER_SDK_PATH/credentials/test/attestation/Chip-Test-PAI-FFF2-8001-Cert.pem \
+    -cd $MATTER_SDK_PATH/credentials/test/certification-declaration/Chip-Test-CD-FFF2-8001.der \
+    --dac-in-secure-cert --target esp32
+```
+*NOTE*: By default, DAC certificates and private key is stored in the NVS factory partition. 
+
+#### Generate a factory partition and store DAC certificate and private key in secure cert partition using DS Peripheral
+```
+esp-matter-mfg-tool -cn "My bulb" -v 0xFFF2 -p 0x8001 --pai \
+    -k $MATTER_SDK_PATH/credentials/test/attestation/Chip-Test-PAI-FFF2-8001-Key.pem \
+    -c $MATTER_SDK_PATH/credentials/test/attestation/Chip-Test-PAI-FFF2-8001-Cert.pem \
+    -cd $MATTER_SDK_PATH/credentials/test/certification-declaration/Chip-Test-CD-FFF2-8001.der
+    --dac-in-secure-cert --ds-peripheral --target esp32h2 --efuse-key-id 1
+```
+*NOTE*: Currently, only esp32h2 supports DS peripheral. 
+
+#### Generate 5 factory partitions [Optional argument : `-n`]
+```
+esp-matter-mfg-tool -n 5 -cn "My bulb" -v 0xFFF2 -p 0x8001 --pai \
+    -k $MATTER_SDK_PATH/credentials/test/attestation/Chip-Test-PAI-FFF2-8001-Key.pem \
+    -c $MATTER_SDK_PATH/credentials/test/attestation/Chip-Test-PAI-FFF2-8001-Cert.pem \
+    -cd $MATTER_SDK_PATH/credentials/test/certification-declaration/Chip-Test-CD-FFF2-8001.der
+```
+
+#### Generate factory partition using existing DAC certificate and private key [Optional arguments : `--dac-cert` and `--dac-key`]
+```
+esp-matter-mfg-tool -cn "My Bulb" -v 0xFFF2 -p 0x8001 --pai \
+    -c $MATTER_SDK_PATH/credentials/test/attestation/Chip-Test-PAI-FFF2-8001-Cert.pem \
+    -cd $MATTER_SDK_PATH/credentials/test/certification-declaration/Chip-Test-CD-FFF2-8001.der \
+    --dac-key DAC_key.pem --dac-cert DAC_cert.pem
+```
+
+#### Generate factory partitions using existing Passcode, Discriminator, and rotating device ID [Optional arguments : `--passcode`, `--discriminator`, and `--rd-id-uid`]
+```
+esp-matter-mfg-tool -cn "My bulb" -v 0xFFF2 -p 0x8001 --pai \
+    -k $MATTER_SDK_PATH/credentials/test/attestation/Chip-Test-PAI-FFF2-8001-Key.pem \
+    -c $MATTER_SDK_PATH/credentials/test/attestation/Chip-Test-PAI-FFF2-8001-Cert.pem \
+    -cd $MATTER_SDK_PATH/credentials/test/certification-declaration/Chip-Test-CD-FFF2-8001.der \
+    --passcode 20202021 --discriminator 3840  --enable-rotating-device-id --rd-id-uid d2f351f57bb9387445a5f92a601d1c14
+```
+
+* NOTE: Script generates only one factory partition if **DAC or Discriminator or Passcode or Rotating-Device-ID** is specified.
+
+#### Generate factory partitions with extra NVS key-values specified using csv and mcsv file [Optional arguments : `--csv` and `--mcsv`]
+```
+esp-matter-mfg-tool -cn "My bulb" -v 0xFFF2 -p 0x8001 --pai \
+    -k $MATTER_SDK_PATH/credentials/test/attestation/Chip-Test-PAI-FFF2-8001-Key.pem \
+    -c $MATTER_SDK_PATH/credentials/test/attestation/Chip-Test-PAI-FFF2-8001-Cert.pem \
+    -cd $MATTER_SDK_PATH/credentials/test/certification-declaration/Chip-Test-CD-FFF2-8001.der \
+    --csv extra_nvs_key_config.csv --mcsv extra_nvs_key_value.csv
+```
+
+Above command will generate `n` number of partitions. Where `n` is the rows in the mcsv file.
+Output binary contains all the chip specific key/value and key/values specified using `--csv` and `--mcsv` option.
+
+#### Generate factory partitions without device attestation certificates and keys
+```
+esp-matter-mfg-tool -v 0xFFF2 -p 0x8001 \
+    -cd $ESP_MATTER_PATH/connectedhomeip/connectedhomeip/credentials/test/certification-declaration/Chip-Test-CD-FFF2-8001.der
+```
+
+* NOTE: These factory partitions are only for firmwares with other ways to get the certificates and sign message with the private key.
+
+## Flashing the manufacturing binary
+Please note that `esp-matter-mfg-tool` only generates manufacturing binary images which need to be flashed onto device using `esptool.py`.
+
+* Flashing a binary image to the device
+```
+esptool.py -p <serial_port> write_flash <address> path/to/<uuid>-partition.bin
+```
+
+* NOTE: First flash your app firmware and then followed by the custom partition binary on the device.
+Please flash the manufacturing binary at the corresponding address of the configured factory partition set by
+[`CHIP_FACTORY_NAMESPACE_PARTITION_LABEL`](https://github.com/project-chip/connectedhomeip/blob/master/config/esp32/components/chip/Kconfig#L856)
+which by default is `nvs`.
+
+## Commissioning the device
+You can commission the device by using either - 
+1. The QR code for Matter commissioners is generated at `out/<vid_pid>/<uuid>/<uuid>-qrcode.png`.
+If QR code is not visible, paste the below link into the browser replacing `<qr_code>` with the **QR code string**
+(eg. `MT:Y.K9042C00KA0648G00` - this is also the default test QR code) and scan the QR code.
+
+```
+https://project-chip.github.io/connectedhomeip/qrcode.html?data=<qr_code>
+```
+
+2. Refer the [docs](https://docs.espressif.com/projects/esp-matter/en/latest/esp32/developing.html#commissioning-and-control)
+for other methods using onboarding payload found at `out/<vid_pid>/<uuid>/<uuid>-onb_codes.csv`. This contains the `QR
+Code String, Manual Pairing Code, Passcode and Discriminator`.
+
+## Encrypting NVS partition
+
+Below are the steps for encrypting the application and factory partition but before proceeding further please READ THE DOCS FIRST. Documentation References:
+
+- [Flash and NVS encryption](https://github.com/project-chip/connectedhomeip/blob/master/docs/guides/esp32/flash_nvs_encryption.md#flash-and-nvs-encryption)
+
+Provide `-e` option along with other options to generate the encrypted NVS partition binary.
+
+It will generate additional partition binary (`<uuid>-keys-partition.bin`) containing the key for decrypting encrypted partition.
+
+- Flash the partition binary containing factory data, as NVS encryption works differently, please flash is without `--encrypt` option
+```
+esptool.py -p (PORT) write_flash (FACTORY_PARTITION_ADDR) path/to/factory_partition.bin
+```
+
+- Flash the partition binary containing encryption keys, these SHALL be flashed with `--encrypt` option
+```
+esptool.py -p (PORT) write_flash --encrypt (NVS_KEYS_PARTITION_ADDR) path/to/nvs_key_partition.bin
+```

esp-matter-mfg-tool-1.0.0/deps/Base38.py

@@ -0,0 +1,49 @@
+#!/usr/bin/env python3
+#
+#    Copyright (c) 2022 Project CHIP Authors
+#    All rights reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+
+# TODO: Implement the decode method
+
+CODES = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
+         'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J',
+         'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T',
+         'U', 'V', 'W', 'X', 'Y', 'Z', '-', '.']
+RADIX = len(CODES)
+BASE38_CHARS_NEEDED_IN_CHUNK = [2, 4, 5]
+MAX_BYTES_IN_CHUNK = 3
+
+
+def encode(bytes):
+    total_bytes = len(bytes)
+    qrcode = ''
+
+    for i in range(0, total_bytes, MAX_BYTES_IN_CHUNK):
+        if (i + MAX_BYTES_IN_CHUNK) > total_bytes:
+            bytes_in_chunk = total_bytes - i
+        else:
+            bytes_in_chunk = MAX_BYTES_IN_CHUNK
+
+        value = 0
+        for j in range(i, i + bytes_in_chunk):
+            value = value + (bytes[j] << (8 * (j - i)))
+
+        base38_chars_needed = BASE38_CHARS_NEEDED_IN_CHUNK[bytes_in_chunk - 1]
+        while base38_chars_needed > 0:
+            qrcode += CODES[int(value % RADIX)]
+            value = int(value / RADIX)
+            base38_chars_needed -= 1
+
+    return qrcode

esp-matter-mfg-tool-1.0.0/deps/__init__.py

@@ -0,0 +1,7 @@
+# SPDX-FileCopyrightText: 2023 Espressif Systems (Shanghai) CO LTD
+# SPDX-License-Identifier: Apache-2.0
+
+import os
+import sys
+
+sys.path.insert(0, os.path.dirname(os.path.realpath(__file__)))

esp-matter-mfg-tool-1.0.0/deps/generate_setup_payload.py

@@ -0,0 +1,170 @@
+#!/usr/bin/env python3
+#
+#    Copyright (c) 2022 Project CHIP Authors
+#    All rights reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+#
+import argparse
+import enum
+import sys
+
+import Base38
+from bitarray import bitarray
+from stdnum.verhoeff import calc_check_digit
+
+# See section 5.1.4.1 Manual Pairing Code in the Matter specification v1.0
+MANUAL_DISCRIMINATOR_LEN = 4
+PINCODE_LEN = 27
+
+MANUAL_CHUNK1_DISCRIMINATOR_MSBITS_LEN = 2
+MANUAL_CHUNK1_DISCRIMINATOR_MSBITS_POS = 0
+MANUAL_CHUNK1_VID_PID_PRESENT_BIT_POS = MANUAL_CHUNK1_DISCRIMINATOR_MSBITS_POS + MANUAL_CHUNK1_DISCRIMINATOR_MSBITS_LEN
+MANUAL_CHUNK1_LEN = 1
+
+MANUAL_CHUNK2_DISCRIMINATOR_LSBITS_LEN = 2
+MANUAL_CHUNK2_PINCODE_LSBITS_LEN = 14
+MANUAL_CHUNK2_PINCODE_LSBITS_POS = 0
+MANUAL_CHUNK2_DISCRIMINATOR_LSBITS_POS = MANUAL_CHUNK2_PINCODE_LSBITS_POS + MANUAL_CHUNK2_PINCODE_LSBITS_LEN
+MANUAL_CHUNK2_LEN = 5
+
+MANUAL_CHUNK3_PINCODE_MSBITS_LEN = 13
+MANUAL_CHUNK3_PINCODE_MSBITS_POS = 0
+MANUAL_CHUNK3_LEN = 4
+
+MANUAL_VID_LEN = 5
+MANUAL_PID_LEN = 5
+
+# See section 5.1.3. QR Code in the Matter specification v1.0
+QRCODE_VERSION_LEN = 3
+QRCODE_DISCRIMINATOR_LEN = 12
+QRCODE_VID_LEN = 16
+QRCODE_PID_LEN = 16
+QRCODE_COMMISSIONING_FLOW_LEN = 2
+QRCODE_DISCOVERY_CAP_BITMASK_LEN = 8
+QRCODE_PADDING_LEN = 4
+QRCODE_VERSION = 0
+QRCODE_PADDING = 0
+
+INVALID_PASSCODES = [00000000, 11111111, 22222222, 33333333, 44444444, 55555555,
+                     66666666, 77777777, 88888888, 99999999, 12345678, 87654321]
+
+
+class CommissioningFlow(enum.IntEnum):
+    Standard = 0,
+    UserIntent = 1,
+    Custom = 2
+
+
+class SetupPayload:
+    def __init__(self, discriminator, pincode, rendezvous=4, flow=CommissioningFlow.Standard, vid=0, pid=0):
+        self.long_discriminator = discriminator
+        self.short_discriminator = discriminator >> 8
+        self.pincode = pincode
+        self.rendezvous = rendezvous
+        self.flow = flow
+        self.vid = vid
+        self.pid = pid
+
+    def manual_chunk1(self):
+        discriminator_shift = (MANUAL_DISCRIMINATOR_LEN - MANUAL_CHUNK1_DISCRIMINATOR_MSBITS_LEN)
+        discriminator_mask = (1 << MANUAL_CHUNK1_DISCRIMINATOR_MSBITS_LEN) - 1
+        discriminator_chunk = (self.short_discriminator >> discriminator_shift) & discriminator_mask
+        vid_pid_present_flag = 0 if self.flow == CommissioningFlow.Standard else 1
+        return (discriminator_chunk << MANUAL_CHUNK1_DISCRIMINATOR_MSBITS_POS) | (vid_pid_present_flag << MANUAL_CHUNK1_VID_PID_PRESENT_BIT_POS)
+
+    def manual_chunk2(self):
+        discriminator_mask = (1 << MANUAL_CHUNK2_DISCRIMINATOR_LSBITS_LEN) - 1
+        pincode_mask = (1 << MANUAL_CHUNK2_PINCODE_LSBITS_LEN) - 1
+        discriminator_chunk = self.short_discriminator & discriminator_mask
+        return ((self.pincode & pincode_mask) << MANUAL_CHUNK2_PINCODE_LSBITS_POS) | (discriminator_chunk << MANUAL_CHUNK2_DISCRIMINATOR_LSBITS_POS)
+
+    def manual_chunk3(self):
+        pincode_shift = PINCODE_LEN - MANUAL_CHUNK3_PINCODE_MSBITS_LEN
+        pincode_mask = (1 << MANUAL_CHUNK3_PINCODE_MSBITS_LEN) - 1
+        return ((self.pincode >> pincode_shift) & pincode_mask) << MANUAL_CHUNK3_PINCODE_MSBITS_POS
+
+    def generate_manualcode(self):
+        payload = str(self.manual_chunk1()).zfill(MANUAL_CHUNK1_LEN)
+        payload += str(self.manual_chunk2()).zfill(MANUAL_CHUNK2_LEN)
+        payload += str(self.manual_chunk3()).zfill(MANUAL_CHUNK3_LEN)
+
+        if self.flow != CommissioningFlow.Standard:
+            payload += str(self.vid).zfill(MANUAL_VID_LEN)
+            payload += str(self.pid).zfill(MANUAL_PID_LEN)
+
+        payload += calc_check_digit(payload)
+        return payload
+
+    def generate_qrcode(self):
+        qrcode_bit_string = '{0:b}'.format(QRCODE_PADDING).zfill(QRCODE_PADDING_LEN)
+        qrcode_bit_string += '{0:b}'.format(self.pincode).zfill(PINCODE_LEN)
+        qrcode_bit_string += '{0:b}'.format(self.long_discriminator).zfill(QRCODE_DISCRIMINATOR_LEN)
+        qrcode_bit_string += '{0:b}'.format(self.rendezvous).zfill(QRCODE_DISCOVERY_CAP_BITMASK_LEN)
+        qrcode_bit_string += '{0:b}'.format(int(self.flow)).zfill(QRCODE_COMMISSIONING_FLOW_LEN)
+        qrcode_bit_string += '{0:b}'.format(self.pid).zfill(QRCODE_PID_LEN)
+        qrcode_bit_string += '{0:b}'.format(self.vid).zfill(QRCODE_VID_LEN)
+        qrcode_bit_string += '{0:b}'.format(QRCODE_VERSION).zfill(QRCODE_VERSION_LEN)
+
+        qrcode_bits = bitarray(qrcode_bit_string)
+        bytes = list(qrcode_bits.tobytes())
+        bytes.reverse()
+        return 'MT:{}'.format(Base38.encode(bytes))
+
+
+def validate_args(args):
+    def check_int_range(value, min_value, max_value, name):
+        if value and ((value < min_value) or (value > max_value)):
+            print('{} is out of range, should be in range from {} to {}'.format(name, min_value, max_value))
+            sys.exit(1)
+
+    if args.passcode is not None:
+        if ((args.passcode < 0x0000001 and args.passcode > 0x5F5E0FE) or (args.passcode in INVALID_PASSCODES)):
+            print('Invalid passcode:' + str(args.passcode))
+            sys.exit(1)
+
+    check_int_range(args.discriminator, 0x0000, 0x0FFF, 'Discriminator')
+    check_int_range(args.product_id, 0x0000, 0xFFFF, 'Product id')
+    check_int_range(args.vendor_id, 0x0000, 0xFFFF, 'Vendor id')
+    check_int_range(args.discovery_cap_bitmask, 0x0001, 0x0007, 'Discovery Capability Mask')
+
+
+def main():
+    def any_base_int(s): return int(s, 0)
+    parser = argparse.ArgumentParser(description='Matter Manual and QRCode Setup Payload Generator Tool')
+    parser.add_argument('-d', '--discriminator', type=any_base_int, required=True,
+                              help='The discriminator for pairing, range: 0x00-0x0FFF')
+    parser.add_argument('-p', '--passcode', type=any_base_int, required=True,
+                              help='The setup passcode for pairing, range: 0x01-0x5F5E0FE')
+    parser.add_argument('-vid', '--vendor-id', type=any_base_int, default=0, help='Vendor id')
+    parser.add_argument('-pid', '--product-id', type=any_base_int, default=0, help='Product id')
+    parser.add_argument('-cf', '--commissioning-flow', type=any_base_int, default=0,
+                               help='Device commissioning flow, 0:Standard, 1:User-Intent, 2:Custom. \
+                               Default is 0.', choices=[0, 1, 2])
+    parser.add_argument('-dm', '--discovery-cap-bitmask', type=any_base_int, default=4,
+                               help='Commissionable device discovery capability bitmask. \
+                               0:SoftAP, 1:BLE, 2:OnNetwork. Default: OnNetwork')
+    args = parser.parse_args()
+    validate_args(args)
+
+    payloads = SetupPayload(args.discriminator, args.passcode, args.discovery_cap_bitmask,
+                            CommissioningFlow(args.commissioning_flow), args.vendor_id, args.product_id)
+    manualcode = payloads.generate_manualcode()
+    qrcode = payloads.generate_qrcode()
+
+    print("Manualcode : {}".format(manualcode))
+    print("QRCode     : {}".format(qrcode))
+
+
+if __name__ == '__main__':
+    main()