weave/src/wrappers/jni/security-support/native/WeaveKeyExportClientNative.cpp - nest-cam/4320010/weave - Git at Google

 /*
  *
  *    Copyright (c) 2013-2017 Nest Labs, Inc.
  *    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.
  */

 /**
  *    @file
  *      Native method implementations for the WeaveKeyExportClient Java wrapper class.
  *
  */

 #ifndef __STDC_LIMIT_MACROS
 #define __STDC_LIMIT_MACROS
 #endif

 #include <stdio.h>
 #include <stdlib.h>
 #include <stdint.h>
 #include <pthread.h>
 #include <jni.h>

 #include <Weave/Core/WeaveCore.h>
 #include <Weave/Core/WeaveKeyIds.h>
 #include <Weave/Support/CodeUtils.h>
 #include <Weave/Profiles/security/WeaveKeyExportClient.h>

 #include "WeaveSecuritySupport.h"
 #include "JNIUtils.h"

 namespace nl {
 namespace Weave {
 namespace SecuritySupport {

 using namespace nl::Weave::Profiles::Security::KeyExport;

 enum
 {
     kMaxPubKeySize = (((WEAVE_CONFIG_MAX_EC_BITS + 7) / 8) + 1) * 2,
     kMaxECDSASigSize = kMaxPubKeySize,
 };

 jlong WeaveKeyExportClientNative::newNativeClient(JNIEnv *env, jclass cls)
 {
     WEAVE_ERROR err = WEAVE_NO_ERROR;
     WeaveStandAloneKeyExportClient *keyExportClient;

     keyExportClient = new WeaveStandAloneKeyExportClient();
     VerifyOrExit(keyExportClient != NULL, err = WEAVE_ERROR_NO_MEMORY);

     keyExportClient->Init();

 exit:
     if (err != WEAVE_NO_ERROR)
     {
         JNIUtils::ThrowError(env, err);
     }

     return (jlong)keyExportClient;
 }

 void WeaveKeyExportClientNative::releaseNativeClient(JNIEnv *env, jclass cls, jlong nativeClientPtr)
 {
     WeaveStandAloneKeyExportClient *keyExportClient = (WeaveStandAloneKeyExportClient *)nativeClientPtr;

     if (keyExportClient != NULL)
     {
         keyExportClient->Reset();
         delete keyExportClient;
     }
 }

 void WeaveKeyExportClientNative::resetNativeClient(JNIEnv *env, jclass cls, jlong nativeClientPtr)
 {
     WeaveStandAloneKeyExportClient *keyExportClient = (WeaveStandAloneKeyExportClient *)nativeClientPtr;

     if (keyExportClient != NULL)
     {
         keyExportClient->Reset();
     }
 }

 jbyteArray WeaveKeyExportClientNative::generateKeyExportRequest_Cert(JNIEnv *env, jclass cls, jlong nativeClientPtr, jint keyId, jlong responderNodeId,
         jbyteArray clientCert, jbyteArray clientKey)
 {
     WEAVE_ERROR err = WEAVE_NO_ERROR;
     WeaveStandAloneKeyExportClient *keyExportClient = (WeaveStandAloneKeyExportClient *)nativeClientPtr;
     const uint8_t *clientCertBuf = NULL;
     const uint8_t *clientKeyBuf = NULL;
     jsize clientCertLen = 0;
     jsize clientKeyLen = 0;
     uint8_t *exportReqBuf = NULL;
     size_t exportReqBufSize;
     uint16_t exportReqLen;
     jbyteArray exportReq = NULL;

     VerifyOrExit(keyExportClient != NULL, err = WEAVE_ERROR_INVALID_ARGUMENT);
     VerifyOrExit(clientCert != NULL, err = WEAVE_ERROR_INVALID_ARGUMENT);
     VerifyOrExit(clientKey != NULL, err = WEAVE_ERROR_INVALID_ARGUMENT);

     clientCertBuf = (uint8_t *)env->GetByteArrayElements(clientCert, 0);
     clientCertLen = env->GetArrayLength(clientCert);

     clientKeyBuf = (uint8_t *)env->GetByteArrayElements(clientKey, 0);
     clientKeyLen = env->GetArrayLength(clientKey);

     exportReqBufSize =
             7                       // Key export request header size
           + kMaxPubKeySize          // Ephemeral public key size
           + kMaxECDSASigSize        // Size of bare signature field
           + clientCertLen           // Size of client certificate
           + 1024;                   // Space for additional signature fields plus encoding overhead

     VerifyOrExit(exportReqBufSize <= UINT16_MAX, err = WEAVE_ERROR_INVALID_ARGUMENT);

     exportReqBuf = (uint8_t *)malloc(exportReqBufSize);
     VerifyOrExit(exportReqBuf != NULL, err = WEAVE_ERROR_NO_MEMORY);

     err = keyExportClient->GenerateKeyExportRequest((uint32_t)keyId, (uint64_t)responderNodeId,
             clientCertBuf, clientCertLen, clientKeyBuf, clientKeyLen,
             exportReqBuf, (uint16_t)exportReqBufSize, exportReqLen);
     SuccessOrExit(err);

     err = JNIUtils::N2J_ByteArray(env, exportReqBuf, exportReqLen, exportReq);
     SuccessOrExit(err);

 exit:
     if (clientCertBuf != NULL)
     {
         env->ReleaseByteArrayElements(clientCert, (jbyte *)clientCertBuf, JNI_ABORT);
     }
     if (clientKeyBuf != NULL)
     {
         env->ReleaseByteArrayElements(clientKey, (jbyte *)clientKeyBuf, JNI_ABORT);
     }
     if (err != WEAVE_NO_ERROR)
     {
         JNIUtils::ThrowError(env, err);
     }
     return exportReq;
 }

 jbyteArray WeaveKeyExportClientNative::generateKeyExportRequest_AccessToken(JNIEnv *env, jclass cls, jlong nativeClientPtr, jint keyId, jlong responderNodeId,
         jbyteArray accessToken)
 {
     WEAVE_ERROR err = WEAVE_NO_ERROR;
     WeaveStandAloneKeyExportClient *keyExportClient = (WeaveStandAloneKeyExportClient *)nativeClientPtr;
     const uint8_t *accessTokenBuf = NULL;
     jsize accessTokenLen = 0;
     uint8_t *exportReqBuf = NULL;
     size_t exportReqBufSize;
     uint16_t exportReqLen;
     jbyteArray exportReq = NULL;

     VerifyOrExit(keyExportClient != NULL, err = WEAVE_ERROR_INVALID_ARGUMENT);
     VerifyOrExit(accessToken != NULL, err = WEAVE_ERROR_INVALID_ARGUMENT);

     accessTokenBuf = (uint8_t *)env->GetByteArrayElements(accessToken, 0);
     accessTokenLen = env->GetArrayLength(accessToken);

     exportReqBufSize =
             7                       // Key export request header size
           + kMaxPubKeySize          // Ephemeral public key size
           + kMaxECDSASigSize        // Size of bare signature field
           + accessTokenLen          // Size equal to at least the total size of the client certificates
           + 1024;                   // Space for additional signature fields plus encoding overhead

     VerifyOrExit(exportReqBufSize <= UINT16_MAX, err = WEAVE_ERROR_INVALID_ARGUMENT);

     exportReqBuf = (uint8_t *)malloc(exportReqBufSize);
     VerifyOrExit(exportReqBuf != NULL, err = WEAVE_ERROR_NO_MEMORY);

     err = keyExportClient->GenerateKeyExportRequest((uint32_t)keyId, (uint64_t)responderNodeId,
             accessTokenBuf, accessTokenLen,
             exportReqBuf, (uint16_t)exportReqBufSize, exportReqLen);
     SuccessOrExit(err);

     err = JNIUtils::N2J_ByteArray(env, exportReqBuf, exportReqLen, exportReq);
     SuccessOrExit(err);

 exit:
     if (accessTokenBuf != NULL)
     {
         env->ReleaseByteArrayElements(accessToken, (jbyte *)accessTokenBuf, JNI_ABORT);
     }
     if (exportReqBuf != NULL)
     {
         free(exportReqBuf);
     }
     if (err != WEAVE_NO_ERROR)
     {
         JNIUtils::ThrowError(env, err);
     }
     return exportReq;
 }

 jbyteArray WeaveKeyExportClientNative::processKeyExportResponse(JNIEnv *env, jclass cls, jlong nativeClientPtr, jlong responderNodeId, jbyteArray exportResp)
 {
     WEAVE_ERROR err = WEAVE_NO_ERROR;
     WeaveStandAloneKeyExportClient *keyExportClient = (WeaveStandAloneKeyExportClient *)nativeClientPtr;
     const uint8_t *exportRespBuf = NULL;
     jsize exportRespLen = 0;
     uint8_t *exportedKeyBuf = NULL;
     size_t exportedKeyBufSize;
     uint16_t exportedKeyLen;
     jbyteArray exportedKey = NULL;
     uint32_t exportedKeyId;

     VerifyOrExit(keyExportClient != NULL, err = WEAVE_ERROR_INVALID_ARGUMENT);
     VerifyOrExit(exportResp != NULL, err = WEAVE_ERROR_INVALID_ARGUMENT);

     exportRespBuf = (uint8_t *)env->GetByteArrayElements(exportResp, 0);
     exportRespLen = env->GetArrayLength(exportResp);

     // Since the exported key is contained within the export response, a buffer of the same size
     // is guaranteed to be sufficient.
     exportedKeyBufSize = exportRespLen;

     exportedKeyBuf = (uint8_t *)malloc(exportedKeyBufSize);
     VerifyOrExit(exportedKeyBuf != NULL, err = WEAVE_ERROR_NO_MEMORY);

     err = keyExportClient->ProcessKeyExportResponse(exportRespBuf, exportRespLen, (uint64_t)responderNodeId, exportedKeyBuf, exportedKeyBufSize, exportedKeyLen, exportedKeyId);
     SuccessOrExit(err);

     err = JNIUtils::N2J_ByteArray(env, exportedKeyBuf, exportedKeyLen, exportedKey);
     SuccessOrExit(err);

 exit:
     if (keyExportClient != NULL)
     {
         keyExportClient->Reset();
     }
     if (exportRespBuf != NULL)
     {
         env->ReleaseByteArrayElements(exportResp, (jbyte *)exportRespBuf, JNI_ABORT);
     }
     if (exportedKeyBuf != NULL)
     {
         free(exportedKeyBuf);
     }
     if (err != WEAVE_NO_ERROR)
     {
         JNIUtils::ThrowError(env, err);
     }
     return exportedKey;
 }

 void WeaveKeyExportClientNative::processKeyExportReconfigure(JNIEnv *env, jclass cls, jlong nativeClientPtr, jbyteArray reconfig)
 {
     WEAVE_ERROR err = WEAVE_NO_ERROR;
     WeaveStandAloneKeyExportClient *keyExportClient = (WeaveStandAloneKeyExportClient *)nativeClientPtr;
     const uint8_t *reconfigBuf = NULL;
     jsize reconfigLen = 0;

     VerifyOrExit(keyExportClient != NULL, err = WEAVE_ERROR_INVALID_ARGUMENT);
     VerifyOrExit(reconfig != NULL, err = WEAVE_ERROR_INVALID_ARGUMENT);

     reconfigBuf = (uint8_t *)env->GetByteArrayElements(reconfig, 0);
     reconfigLen = env->GetArrayLength(reconfig);

     err = keyExportClient->ProcessKeyExportReconfigure(reconfigBuf, reconfigLen);
     SuccessOrExit(err);

 exit:
     if (reconfigBuf != NULL)
     {
         env->ReleaseByteArrayElements(reconfig, (jbyte *)reconfigBuf, JNI_ABORT);
     }
     if (err != WEAVE_NO_ERROR)
     {
         JNIUtils::ThrowError(env, err);
     }
 }

 jboolean WeaveKeyExportClientNative::allowNestDevelopmentDevices(JNIEnv *env, jclass cls, jlong nativeClientPtr)
 {
     WEAVE_ERROR err = WEAVE_NO_ERROR;
     WeaveStandAloneKeyExportClient *keyExportClient = (WeaveStandAloneKeyExportClient *)nativeClientPtr;
     jboolean res = JNI_FALSE;

     VerifyOrExit(keyExportClient != NULL, err = WEAVE_ERROR_INVALID_ARGUMENT);

     res = keyExportClient->AllowNestDevelopmentDevices() ? JNI_TRUE : JNI_FALSE;

 exit:
     if (err != WEAVE_NO_ERROR)
     {
         JNIUtils::ThrowError(env, err);
     }
     return res;
 }

 void WeaveKeyExportClientNative::setAllowNestDevelopmentDevices(JNIEnv *env, jclass cls, jlong nativeClientPtr, jboolean val)
 {
     WEAVE_ERROR err = WEAVE_NO_ERROR;
     WeaveStandAloneKeyExportClient *keyExportClient = (WeaveStandAloneKeyExportClient *)nativeClientPtr;

     VerifyOrExit(keyExportClient != NULL, err = WEAVE_ERROR_INVALID_ARGUMENT);

     keyExportClient->AllowNestDevelopmentDevices(val != JNI_FALSE);

 exit:
     if (err != WEAVE_NO_ERROR)
     {
         JNIUtils::ThrowError(env, err);
     }
 }

 jboolean WeaveKeyExportClientNative::allowSHA1DeviceCertificates(JNIEnv *env, jclass cls, jlong nativeClientPtr)
 {
     WEAVE_ERROR err = WEAVE_NO_ERROR;
     WeaveStandAloneKeyExportClient *keyExportClient = (WeaveStandAloneKeyExportClient *)nativeClientPtr;
     jboolean res = JNI_FALSE;

     VerifyOrExit(keyExportClient != NULL, err = WEAVE_ERROR_INVALID_ARGUMENT);

     res = keyExportClient->AllowSHA1DeviceCerts() ? JNI_TRUE : JNI_FALSE;

 exit:
     if (err != WEAVE_NO_ERROR)
     {
         JNIUtils::ThrowError(env, err);
     }
     return res;
 }

 void WeaveKeyExportClientNative::setAllowSHA1DeviceCertificates(JNIEnv *env, jclass cls, jlong nativeClientPtr, jboolean val)
 {
     WEAVE_ERROR err = WEAVE_NO_ERROR;
     WeaveStandAloneKeyExportClient *keyExportClient = (WeaveStandAloneKeyExportClient *)nativeClientPtr;

     VerifyOrExit(keyExportClient != NULL, err = WEAVE_ERROR_INVALID_ARGUMENT);

     keyExportClient->AllowSHA1DeviceCerts(val != JNI_FALSE);

 exit:
     if (err != WEAVE_NO_ERROR)
     {
         JNIUtils::ThrowError(env, err);
     }
 }


 } // namespace SecuritySupport
 } // namespace Weave
 } // namespace nl
	/*
	*
	* Copyright (c) 2013-2017 Nest Labs, Inc.
	* 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.
	*/

	/**
	* @file
	* Native method implementations for the WeaveKeyExportClient Java wrapper class.
	*
	*/

	#ifndef __STDC_LIMIT_MACROS
	#define __STDC_LIMIT_MACROS
	#endif

	#include <stdio.h>
	#include <stdlib.h>
	#include <stdint.h>
	#include <pthread.h>
	#include <jni.h>

	#include <Weave/Core/WeaveCore.h>
	#include <Weave/Core/WeaveKeyIds.h>
	#include <Weave/Support/CodeUtils.h>
	#include <Weave/Profiles/security/WeaveKeyExportClient.h>

	#include "WeaveSecuritySupport.h"
	#include "JNIUtils.h"

	namespace nl {
	namespace Weave {
	namespace SecuritySupport {

	using namespace nl::Weave::Profiles::Security::KeyExport;

	enum
	{
	kMaxPubKeySize = (((WEAVE_CONFIG_MAX_EC_BITS + 7) / 8) + 1) * 2,
	kMaxECDSASigSize = kMaxPubKeySize,
	};

	jlong WeaveKeyExportClientNative::newNativeClient(JNIEnv *env, jclass cls)
	{
	WEAVE_ERROR err = WEAVE_NO_ERROR;
	WeaveStandAloneKeyExportClient *keyExportClient;

	keyExportClient = new WeaveStandAloneKeyExportClient();
	VerifyOrExit(keyExportClient != NULL, err = WEAVE_ERROR_NO_MEMORY);

	keyExportClient->Init();

	exit:
	if (err != WEAVE_NO_ERROR)
	{
	JNIUtils::ThrowError(env, err);
	}

	return (jlong)keyExportClient;
	}

	void WeaveKeyExportClientNative::releaseNativeClient(JNIEnv *env, jclass cls, jlong nativeClientPtr)
	{
	WeaveStandAloneKeyExportClient keyExportClient = (WeaveStandAloneKeyExportClient )nativeClientPtr;

	if (keyExportClient != NULL)
	{
	keyExportClient->Reset();
	delete keyExportClient;
	}
	}

	void WeaveKeyExportClientNative::resetNativeClient(JNIEnv *env, jclass cls, jlong nativeClientPtr)
	{
	WeaveStandAloneKeyExportClient keyExportClient = (WeaveStandAloneKeyExportClient )nativeClientPtr;

	if (keyExportClient != NULL)
	{
	keyExportClient->Reset();
	}
	}

	jbyteArray WeaveKeyExportClientNative::generateKeyExportRequest_Cert(JNIEnv *env, jclass cls, jlong nativeClientPtr, jint keyId, jlong responderNodeId,
	jbyteArray clientCert, jbyteArray clientKey)
	{
	WEAVE_ERROR err = WEAVE_NO_ERROR;
	WeaveStandAloneKeyExportClient keyExportClient = (WeaveStandAloneKeyExportClient )nativeClientPtr;
	const uint8_t *clientCertBuf = NULL;
	const uint8_t *clientKeyBuf = NULL;
	jsize clientCertLen = 0;
	jsize clientKeyLen = 0;
	uint8_t *exportReqBuf = NULL;
	size_t exportReqBufSize;
	uint16_t exportReqLen;
	jbyteArray exportReq = NULL;

	VerifyOrExit(keyExportClient != NULL, err = WEAVE_ERROR_INVALID_ARGUMENT);
	VerifyOrExit(clientCert != NULL, err = WEAVE_ERROR_INVALID_ARGUMENT);
	VerifyOrExit(clientKey != NULL, err = WEAVE_ERROR_INVALID_ARGUMENT);

	clientCertBuf = (uint8_t *)env->GetByteArrayElements(clientCert, 0);
	clientCertLen = env->GetArrayLength(clientCert);

	clientKeyBuf = (uint8_t *)env->GetByteArrayElements(clientKey, 0);
	clientKeyLen = env->GetArrayLength(clientKey);

	exportReqBufSize =
	7 // Key export request header size
	+ kMaxPubKeySize // Ephemeral public key size
	+ kMaxECDSASigSize // Size of bare signature field
	+ clientCertLen // Size of client certificate
	+ 1024; // Space for additional signature fields plus encoding overhead

	VerifyOrExit(exportReqBufSize <= UINT16_MAX, err = WEAVE_ERROR_INVALID_ARGUMENT);

	exportReqBuf = (uint8_t *)malloc(exportReqBufSize);
	VerifyOrExit(exportReqBuf != NULL, err = WEAVE_ERROR_NO_MEMORY);

	err = keyExportClient->GenerateKeyExportRequest((uint32_t)keyId, (uint64_t)responderNodeId,
	clientCertBuf, clientCertLen, clientKeyBuf, clientKeyLen,
	exportReqBuf, (uint16_t)exportReqBufSize, exportReqLen);
	SuccessOrExit(err);

	err = JNIUtils::N2J_ByteArray(env, exportReqBuf, exportReqLen, exportReq);
	SuccessOrExit(err);

	exit:
	if (clientCertBuf != NULL)
	{
	env->ReleaseByteArrayElements(clientCert, (jbyte *)clientCertBuf, JNI_ABORT);
	}
	if (clientKeyBuf != NULL)
	{
	env->ReleaseByteArrayElements(clientKey, (jbyte *)clientKeyBuf, JNI_ABORT);
	}
	if (err != WEAVE_NO_ERROR)
	{
	JNIUtils::ThrowError(env, err);
	}
	return exportReq;
	}

	jbyteArray WeaveKeyExportClientNative::generateKeyExportRequest_AccessToken(JNIEnv *env, jclass cls, jlong nativeClientPtr, jint keyId, jlong responderNodeId,
	jbyteArray accessToken)
	{
	WEAVE_ERROR err = WEAVE_NO_ERROR;
	WeaveStandAloneKeyExportClient keyExportClient = (WeaveStandAloneKeyExportClient )nativeClientPtr;
	const uint8_t *accessTokenBuf = NULL;
	jsize accessTokenLen = 0;
	uint8_t *exportReqBuf = NULL;
	size_t exportReqBufSize;
	uint16_t exportReqLen;
	jbyteArray exportReq = NULL;

	VerifyOrExit(keyExportClient != NULL, err = WEAVE_ERROR_INVALID_ARGUMENT);
	VerifyOrExit(accessToken != NULL, err = WEAVE_ERROR_INVALID_ARGUMENT);

	accessTokenBuf = (uint8_t *)env->GetByteArrayElements(accessToken, 0);
	accessTokenLen = env->GetArrayLength(accessToken);

	exportReqBufSize =
	7 // Key export request header size
	+ kMaxPubKeySize // Ephemeral public key size
	+ kMaxECDSASigSize // Size of bare signature field
	+ accessTokenLen // Size equal to at least the total size of the client certificates
	+ 1024; // Space for additional signature fields plus encoding overhead

	VerifyOrExit(exportReqBufSize <= UINT16_MAX, err = WEAVE_ERROR_INVALID_ARGUMENT);

	exportReqBuf = (uint8_t *)malloc(exportReqBufSize);
	VerifyOrExit(exportReqBuf != NULL, err = WEAVE_ERROR_NO_MEMORY);

	err = keyExportClient->GenerateKeyExportRequest((uint32_t)keyId, (uint64_t)responderNodeId,
	accessTokenBuf, accessTokenLen,
	exportReqBuf, (uint16_t)exportReqBufSize, exportReqLen);
	SuccessOrExit(err);

	err = JNIUtils::N2J_ByteArray(env, exportReqBuf, exportReqLen, exportReq);
	SuccessOrExit(err);

	exit:
	if (accessTokenBuf != NULL)
	{
	env->ReleaseByteArrayElements(accessToken, (jbyte *)accessTokenBuf, JNI_ABORT);
	}
	if (exportReqBuf != NULL)
	{
	free(exportReqBuf);
	}
	if (err != WEAVE_NO_ERROR)
	{
	JNIUtils::ThrowError(env, err);
	}
	return exportReq;
	}

	jbyteArray WeaveKeyExportClientNative::processKeyExportResponse(JNIEnv *env, jclass cls, jlong nativeClientPtr, jlong responderNodeId, jbyteArray exportResp)
	{
	WEAVE_ERROR err = WEAVE_NO_ERROR;
	WeaveStandAloneKeyExportClient keyExportClient = (WeaveStandAloneKeyExportClient )nativeClientPtr;
	const uint8_t *exportRespBuf = NULL;
	jsize exportRespLen = 0;
	uint8_t *exportedKeyBuf = NULL;
	size_t exportedKeyBufSize;
	uint16_t exportedKeyLen;
	jbyteArray exportedKey = NULL;
	uint32_t exportedKeyId;

	VerifyOrExit(keyExportClient != NULL, err = WEAVE_ERROR_INVALID_ARGUMENT);
	VerifyOrExit(exportResp != NULL, err = WEAVE_ERROR_INVALID_ARGUMENT);

	exportRespBuf = (uint8_t *)env->GetByteArrayElements(exportResp, 0);
	exportRespLen = env->GetArrayLength(exportResp);

	// Since the exported key is contained within the export response, a buffer of the same size
	// is guaranteed to be sufficient.
	exportedKeyBufSize = exportRespLen;

	exportedKeyBuf = (uint8_t *)malloc(exportedKeyBufSize);
	VerifyOrExit(exportedKeyBuf != NULL, err = WEAVE_ERROR_NO_MEMORY);

	err = keyExportClient->ProcessKeyExportResponse(exportRespBuf, exportRespLen, (uint64_t)responderNodeId, exportedKeyBuf, exportedKeyBufSize, exportedKeyLen, exportedKeyId);
	SuccessOrExit(err);

	err = JNIUtils::N2J_ByteArray(env, exportedKeyBuf, exportedKeyLen, exportedKey);
	SuccessOrExit(err);

	exit:
	if (keyExportClient != NULL)
	{
	keyExportClient->Reset();
	}
	if (exportRespBuf != NULL)
	{
	env->ReleaseByteArrayElements(exportResp, (jbyte *)exportRespBuf, JNI_ABORT);
	}
	if (exportedKeyBuf != NULL)
	{
	free(exportedKeyBuf);
	}
	if (err != WEAVE_NO_ERROR)
	{
	JNIUtils::ThrowError(env, err);
	}
	return exportedKey;
	}

	void WeaveKeyExportClientNative::processKeyExportReconfigure(JNIEnv *env, jclass cls, jlong nativeClientPtr, jbyteArray reconfig)
	{
	WEAVE_ERROR err = WEAVE_NO_ERROR;
	WeaveStandAloneKeyExportClient keyExportClient = (WeaveStandAloneKeyExportClient )nativeClientPtr;
	const uint8_t *reconfigBuf = NULL;
	jsize reconfigLen = 0;

	VerifyOrExit(keyExportClient != NULL, err = WEAVE_ERROR_INVALID_ARGUMENT);
	VerifyOrExit(reconfig != NULL, err = WEAVE_ERROR_INVALID_ARGUMENT);

	reconfigBuf = (uint8_t *)env->GetByteArrayElements(reconfig, 0);
	reconfigLen = env->GetArrayLength(reconfig);

	err = keyExportClient->ProcessKeyExportReconfigure(reconfigBuf, reconfigLen);
	SuccessOrExit(err);

	exit:
	if (reconfigBuf != NULL)
	{
	env->ReleaseByteArrayElements(reconfig, (jbyte *)reconfigBuf, JNI_ABORT);
	}
	if (err != WEAVE_NO_ERROR)
	{
	JNIUtils::ThrowError(env, err);
	}
	}

	jboolean WeaveKeyExportClientNative::allowNestDevelopmentDevices(JNIEnv *env, jclass cls, jlong nativeClientPtr)
	{
	WEAVE_ERROR err = WEAVE_NO_ERROR;
	WeaveStandAloneKeyExportClient keyExportClient = (WeaveStandAloneKeyExportClient )nativeClientPtr;
	jboolean res = JNI_FALSE;

	VerifyOrExit(keyExportClient != NULL, err = WEAVE_ERROR_INVALID_ARGUMENT);

	res = keyExportClient->AllowNestDevelopmentDevices() ? JNI_TRUE : JNI_FALSE;

	exit:
	if (err != WEAVE_NO_ERROR)
	{
	JNIUtils::ThrowError(env, err);
	}
	return res;
	}

	void WeaveKeyExportClientNative::setAllowNestDevelopmentDevices(JNIEnv *env, jclass cls, jlong nativeClientPtr, jboolean val)
	{
	WEAVE_ERROR err = WEAVE_NO_ERROR;
	WeaveStandAloneKeyExportClient keyExportClient = (WeaveStandAloneKeyExportClient )nativeClientPtr;

	VerifyOrExit(keyExportClient != NULL, err = WEAVE_ERROR_INVALID_ARGUMENT);

	keyExportClient->AllowNestDevelopmentDevices(val != JNI_FALSE);

	exit:
	if (err != WEAVE_NO_ERROR)
	{
	JNIUtils::ThrowError(env, err);
	}
	}

	jboolean WeaveKeyExportClientNative::allowSHA1DeviceCertificates(JNIEnv *env, jclass cls, jlong nativeClientPtr)
	{
	WEAVE_ERROR err = WEAVE_NO_ERROR;
	WeaveStandAloneKeyExportClient keyExportClient = (WeaveStandAloneKeyExportClient )nativeClientPtr;
	jboolean res = JNI_FALSE;

	VerifyOrExit(keyExportClient != NULL, err = WEAVE_ERROR_INVALID_ARGUMENT);

	res = keyExportClient->AllowSHA1DeviceCerts() ? JNI_TRUE : JNI_FALSE;

	exit:
	if (err != WEAVE_NO_ERROR)
	{
	JNIUtils::ThrowError(env, err);
	}
	return res;
	}

	void WeaveKeyExportClientNative::setAllowSHA1DeviceCertificates(JNIEnv *env, jclass cls, jlong nativeClientPtr, jboolean val)
	{
	WEAVE_ERROR err = WEAVE_NO_ERROR;
	WeaveStandAloneKeyExportClient keyExportClient = (WeaveStandAloneKeyExportClient )nativeClientPtr;

	VerifyOrExit(keyExportClient != NULL, err = WEAVE_ERROR_INVALID_ARGUMENT);

	keyExportClient->AllowSHA1DeviceCerts(val != JNI_FALSE);

	exit:
	if (err != WEAVE_NO_ERROR)
	{
	JNIUtils::ThrowError(env, err);
	}
	}


	} // namespace SecuritySupport
	} // namespace Weave
	} // namespace nl