src/setup_payload/QRCodeSetupPayloadGenerator.cpp

   1 /*
   2  *
   3  *    Copyright (c) 2020 Project CHIP Authors
   4  *
   5  *    Licensed under the Apache License, Version 2.0 (the "License");
   6  *    you may not use this file except in compliance with the License.
   7  *    You may obtain a copy of the License at
   8  *
   9  *        http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  *    Unless required by applicable law or agreed to in writing, software
  12  *    distributed under the License is distributed on an "AS IS" BASIS,
  13  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  *    See the License for the specific language governing permissions and
  15  *    limitations under the License.
  16  */
  17
  18 /**
  19  *    @file
  20  *      This file implements a QRCode Setup Payload generator in accordance
  21  *      with the CHIP specification.
  22  *
  23  */
  24
  25 #include "QRCodeSetupPayloadGenerator.h"
  26 #include "Base41.h"
  27
  28 #include <core/CHIPCore.h>
  29 #include <core/CHIPTLV.h>
  30 #include <core/CHIPTLVData.hpp>
  31 #include <core/CHIPTLVDebug.hpp>
  32 #include <core/CHIPTLVUtilities.hpp>
  33 #include <protocols/Protocols.h>
  34 #include <support/CodeUtils.h>
  35 #include <support/RandUtils.h>
  36
  37 #include <stdlib.h>
  38 #include <string.h>
  39
  40 namespace chip {
  41
  42 // Populates numberOfBits starting from LSB of input into bits, which is assumed to be zero-initialized
  43 static CHIP_ERROR populateBits(uint8_t * bits, size_t & offset, uint64_t input, size_t numberOfBits,
  44                                size_t totalPayloadDataSizeInBits)
  45 {
  46     CHIP_ERROR err = CHIP_NO_ERROR;
  47     size_t index;
  48
  49     VerifyOrExit(offset + numberOfBits <= totalPayloadDataSizeInBits, err = CHIP_ERROR_INVALID_ARGUMENT);
  50     VerifyOrExit(input < 1u << numberOfBits, err = CHIP_ERROR_INVALID_ARGUMENT);
  51
  52     index = offset;
  53     offset += numberOfBits;
  54     while (input != 0)
  55     {
  56         if (input & 1)
  57         {
  58             bits[index / 8] |= static_cast<uint8_t>(1 << index % 8);
  59         }
  60         index++;
  61         input >>= 1;
  62     }
  63 exit:
  64     return err;
  65 }
  66
  67 static CHIP_ERROR populateTLVBits(uint8_t * bits, size_t & offset, const uint8_t * tlvBuf, size_t tlvBufSizeInBytes,
  68                                   size_t totalPayloadDataSizeInBits)
  69 {
  70     CHIP_ERROR err = CHIP_NO_ERROR;
  71     for (size_t i = 0; i < tlvBufSizeInBytes; i++)
  72     {
  73         uint8_t value = tlvBuf[i];
  74         err           = populateBits(bits, offset, value, 8, totalPayloadDataSizeInBits);
  75         if (err != CHIP_NO_ERROR)
  76         {
  77             return err;
  78         }
  79     }
  80     return err;
  81 }
  82
  83 CHIP_ERROR writeTag(TLV::TLVWriter & writer, uint64_t tag, OptionalQRCodeInfo & info)
  84 {
  85     CHIP_ERROR err = CHIP_NO_ERROR;
  86
  87     if (info.type == optionalQRCodeInfoTypeString)
  88     {
  89         err = writer.PutString(tag, info.data.c_str());
  90     }
  91     else if (info.type == optionalQRCodeInfoTypeInt32)
  92     {
  93         err = writer.Put(tag, info.int32);
  94     }
  95     else
  96     {
  97         err = CHIP_ERROR_INVALID_ARGUMENT;
  98     }
  99
 100     return err;
 101 }
 102
 103 CHIP_ERROR writeTag(TLV::TLVWriter & writer, uint64_t tag, OptionalQRCodeInfoExtension & info)
 104 {
 105     CHIP_ERROR err = CHIP_NO_ERROR;
 106
 107     if (info.type == optionalQRCodeInfoTypeString || info.type == optionalQRCodeInfoTypeInt32)
 108     {
 109         err = writeTag(writer, tag, static_cast<OptionalQRCodeInfo &>(info));
 110     }
 111     else if (info.type == optionalQRCodeInfoTypeInt64)
 112     {
 113         err = writer.Put(tag, info.int64);
 114     }
 115     else if (info.type == optionalQRCodeInfoTypeUInt32)
 116     {
 117         err = writer.Put(tag, info.uint32);
 118     }
 119     else if (info.type == optionalQRCodeInfoTypeUInt64)
 120     {
 121         err = writer.Put(tag, info.uint64);
 122     }
 123     else
 124     {
 125         err = CHIP_ERROR_INVALID_ARGUMENT;
 126     }
 127
 128     return err;
 129 }
 130
 131 CHIP_ERROR QRCodeSetupPayloadGenerator::generateTLVFromOptionalData(SetupPayload & outPayload, uint8_t * tlvDataStart,
 132                                                                     uint32_t maxLen, size_t & tlvDataLengthInBytes)
 133 {
 134     CHIP_ERROR err                                                 = CHIP_NO_ERROR;
 135     std::vector<OptionalQRCodeInfo> optionalData                   = outPayload.getAllOptionalVendorData();
 136     std::vector<OptionalQRCodeInfoExtension> optionalExtensionData = outPayload.getAllOptionalExtensionData();
 137     VerifyOrExit(!optionalData.empty() || !optionalExtensionData.empty(), err = CHIP_NO_ERROR);
 138
 139     TLV::TLVWriter rootWriter;
 140     rootWriter.Init(tlvDataStart, maxLen);
 141
 142     TLV::TLVWriter innerStructureWriter;
 143
 144     err = rootWriter.OpenContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, innerStructureWriter);
 145     SuccessOrExit(err);
 146
 147     for (OptionalQRCodeInfo info : optionalData)
 148     {
 149         err = writeTag(innerStructureWriter, TLV::ContextTag(info.tag), info);
 150         SuccessOrExit(err);
 151     }
 152
 153     for (OptionalQRCodeInfoExtension info : optionalExtensionData)
 154     {
 155         err = writeTag(innerStructureWriter, TLV::ContextTag(info.tag), info);
 156         SuccessOrExit(err);
 157     }
 158
 159     err = rootWriter.CloseContainer(innerStructureWriter);
 160     SuccessOrExit(err);
 161
 162     err = rootWriter.Finalize();
 163     SuccessOrExit(err);
 164
 165     tlvDataLengthInBytes = rootWriter.GetLengthWritten();
 166
 167 exit:
 168     return err;
 169 }
 170
 171 static CHIP_ERROR generateBitSet(SetupPayload & payload, uint8_t * bits, uint8_t * tlvDataStart, size_t tlvDataLengthInBytes)
 172 {
 173     CHIP_ERROR err                = CHIP_NO_ERROR;
 174     size_t offset                 = 0;
 175     size_t totalPayloadSizeInBits = kTotalPayloadDataSizeInBits + (tlvDataLengthInBytes * 8);
 176     err = populateBits(bits, offset, payload.version, kVersionFieldLengthInBits, kTotalPayloadDataSizeInBits);
 177     err = populateBits(bits, offset, payload.vendorID, kVendorIDFieldLengthInBits, kTotalPayloadDataSizeInBits);
 178     err = populateBits(bits, offset, payload.productID, kProductIDFieldLengthInBits, kTotalPayloadDataSizeInBits);
 179     err = populateBits(bits, offset, payload.requiresCustomFlow, kCustomFlowRequiredFieldLengthInBits, kTotalPayloadDataSizeInBits);
 180     err = populateBits(bits, offset, static_cast<uint16_t>(payload.rendezvousInformation), kRendezvousInfoFieldLengthInBits,
 181                        kTotalPayloadDataSizeInBits);
 182     err = populateBits(bits, offset, payload.discriminator, kPayloadDiscriminatorFieldLengthInBits, kTotalPayloadDataSizeInBits);
 183     err = populateBits(bits, offset, payload.setUpPINCode, kSetupPINCodeFieldLengthInBits, kTotalPayloadDataSizeInBits);
 184     err = populateBits(bits, offset, 0, kPaddingFieldLengthInBits, kTotalPayloadDataSizeInBits);
 185     err = populateTLVBits(bits, offset, tlvDataStart, tlvDataLengthInBytes, totalPayloadSizeInBits);
 186     return err;
 187 }
 188
 189 // TODO: issue #3663 - Unbounded stack in payloadBase41RepresentationWithTLV()
 190 #if !defined(__clang__)
 191 #pragma GCC diagnostic push
 192 #pragma GCC diagnostic ignored "-Wstack-usage="
 193 #endif
 194
 195 static CHIP_ERROR payloadBase41RepresentationWithTLV(SetupPayload & setupPayload, std::string & base41Representation,
 196                                                      size_t bitsetSize, uint8_t * tlvDataStart, size_t tlvDataLengthInBytes)
 197 {
 198     uint8_t bits[bitsetSize];
 199     memset(bits, 0, bitsetSize);
 200     std::string encodedPayload;
 201     CHIP_ERROR err = generateBitSet(setupPayload, bits, tlvDataStart, tlvDataLengthInBytes);
 202     SuccessOrExit(err);
 203
 204     encodedPayload = base41Encode(bits, ArraySize(bits));
 205     encodedPayload.insert(0, kQRCodePrefix);
 206     base41Representation = encodedPayload;
 207 exit:
 208     return err;
 209 }
 210
 211 CHIP_ERROR QRCodeSetupPayloadGenerator::payloadBase41Representation(std::string & base41Representation)
 212 {
 213     // 6.1.2.2. Table: Packed Binary Data Structure
 214     // The TLV Data should be 0 length if TLV is not included.
 215     return payloadBase41Representation(base41Representation, nullptr, 0);
 216 }
 217
 218 CHIP_ERROR QRCodeSetupPayloadGenerator::payloadBase41Representation(std::string & base41Representation, uint8_t * tlvDataStart,
 219                                                                     uint32_t tlvDataStartSize)
 220 {
 221     CHIP_ERROR err              = CHIP_NO_ERROR;
 222     size_t tlvDataLengthInBytes = 0;
 223
 224     VerifyOrExit(mPayload.isValidQRCodePayload(), err = CHIP_ERROR_INVALID_ARGUMENT);
 225     err = generateTLVFromOptionalData(mPayload, tlvDataStart, tlvDataStartSize, tlvDataLengthInBytes);
 226     SuccessOrExit(err);
 227
 228     err = payloadBase41RepresentationWithTLV(mPayload, base41Representation, kTotalPayloadDataSizeInBytes + tlvDataLengthInBytes,
 229                                              tlvDataStart, tlvDataLengthInBytes);
 230     SuccessOrExit(err);
 231
 232 exit:
 233     return err;
 234 }
 235
 236 #if !defined(__clang__)
 237 #pragma GCC diagnostic pop // -Wstack-usage
 238 #endif
 239
 240 } // namespace chip