#include <stdlib.h>
#define RET_IF_FAIL_VOID(cond) do {\
- if (!(cond)){\
+ if (!(cond)) {\
return;\
- }\
-} while(0)
+ } \
+} while (0)
#define RET_IF_FAIL(cond, err) do {\
- if (!(cond)){\
+ if (!(cond)) {\
return err;\
- }\
-} while(0)
+ } \
+} while (0)
#define CATCH_IF_FAIL(cond) do {\
- if (!(cond)){\
+ if (!(cond)) {\
goto CATCH;\
- }\
-} while(0)
+ } \
+} while (0)
#define CATCH_IF_FAIL_X(cond, expr) do {\
- if (!(cond)){\
+ if (!(cond)) {\
expr;\
goto CATCH;\
- }\
-} while(0)
+ } \
+} while (0)
#define GOTO_IF_FAIL(cond, catch_block) do {\
- if (!(cond)){\
+ if (!(cond)) {\
goto catch_block;\
- }\
-} while(0)
+ } \
+} while (0)
#define SAFE_DELETE(x) do {\
if (x != NULL) {\
free(x); \
x = NULL;\
- }\
-} while(0)
+ } \
+} while (0)
#define _SAFE_DUP(x) ((x) ? strdup(x) : NULL)
#include <pkgmgr-info.h>
class AsmCrypto {
-
public:
static int genRandom(unsigned char *random, int num);
static bool genHash256(const void* input, unsigned long length, unsigned char* md);
static int genRSAKeyPair(char *pubkey, char *prikey, const char *passwd, int keysize);
- static int genRSASignValue(const char *privkey, const char * passwd, const unsigned char * msg, unsigned int len, unsigned char *sign,unsigned int *signlen);
+ static int genRSASignValue(const char *privkey, const char * passwd, const unsigned char * msg, unsigned int len, unsigned char *sign, unsigned int *signlen);
static int genB64Encode(const unsigned char *input, int inlen, unsigned char * output, int *outlen);
static unsigned char *ToBase64Url(const unsigned char *input, int inputLen);
static int genB64Decodes(const unsigned char *input, int inlen, unsigned char * output, int *outlen);
AsmCrypto::logDataToFile(const char *file_name_prefix, const char *data, int data_len)
{
char fn[128] = {0, };
- char resolved_path[128];
+ char *realpath_res = NULL;
snprintf(fn, 127, "%s%s", LOG_FILE_PATH, file_name_prefix);
- if(realpath(fn, resolved_path) == NULL) {
+ realpath_res = realpath(fn, NULL);
+ if (realpath_res == NULL) {
_ERR("realpath error");
+ SAFE_DELETE(realpath_res);
return;
}
FILE *fp = fopen(fn, "w+");
- if (fp == NULL)
+ if (fp == NULL) {
+ SAFE_DELETE(realpath_res);
return;
+ }
int num = fwrite(data, sizeof(char), data_len, fp);
_INFO("[%d] bytes logged in [%s]", num, fn);
fclose(fp);
+ SAFE_DELETE(realpath_res);
}
void
AsmCrypto::logRawDataToFile(const char *file_name_prefix, const unsigned char *data, int data_len)
{
char fn[128] = {0, };
- char resolved_path[128];
+ char *realpath_res = NULL;
snprintf(fn, 127, "%s%s", LOG_FILE_PATH, file_name_prefix);
- if(realpath(fn, resolved_path) == NULL) {
+ realpath_res = realpath(fn, NULL);
+ if (realpath_res == NULL) {
_ERR("realpath error");
+ SAFE_DELETE(realpath_res);
return;
}
FILE *fp = fopen(fn, "w+");
- if (fp == NULL)
+ if (fp == NULL) {
+ SAFE_DELETE(realpath_res);
return;
+ }
int num = fwrite(data, sizeof(unsigned char), data_len, fp);
_INFO("[%d] bytes logged in [%s]", num, fn);
fclose(fp);
+ SAFE_DELETE(realpath_res);
}
static int
_der_cert_s *pcert;
- if(raw_cert == NULL || cert_size <= 0 || ppcert == NULL) {
+ if (raw_cert == NULL || cert_size <= 0 || ppcert == NULL) {
return -1;
}
pcert = static_cast<_der_cert_s*>(malloc(sizeof(_der_cert_s)));
- if(pcert == NULL) {
+ if (pcert == NULL) {
return -1;
}
pcert->raw_cert = reinterpret_cast<unsigned char*>(malloc(cert_size));
- if(pcert->raw_cert == NULL) {
+ if (pcert->raw_cert == NULL) {
free(pcert);
return -1;
}
{
_INFO("__load_cert_from_x509 start");
- if(xCert == NULL) {
+ if (xCert == NULL) {
return -1;
}
return macStr;
}
- char resolved_path[128];
+ char *realpath_res = NULL;
- if(realpath(ASM_CONFIG_FILE, resolved_path) == NULL) {
+ realpath_res = realpath(ASM_CONFIG_FILE, NULL);
+ if (realpath_res == NULL) {
_ERR("realpath error");
+ SAFE_DELETE(realpath_res);
return std::string();
}
SAFE_DELETE(mac);
bt_deinitialize();
+ SAFE_DELETE(realpath_res);
return tok;
- }
- else {
+ } else {
fseek(file, 0, SEEK_END);
long size = ftell(file);
if (size <= 0) {
_END;
bt_deinitialize();
+ SAFE_DELETE(realpath_res);
return std::string();
} else if (size > 1000) {
_ERR("Too big config file, size=[%d], allowed=[1000]", size);
_END;
bt_deinitialize();
+ SAFE_DELETE(realpath_res);
return std::string();
}
_END;
bt_deinitialize();
+ SAFE_DELETE(realpath_res);
return std::string();
}
asmTok = strdup(config);
SAFE_DELETE(config);
- bt_deinitialize();
+ SAFE_DELETE(realpath_res);
return tok;
}
}
{
int ret;
ret = RAND_bytes(random, num);
- if(ret != -1)
- {
+ if (ret != -1) {
return 0;
- }
- else
- {
+ } else {
return -1;
}
}
AsmCrypto::genHash256(const void* input, unsigned long length, unsigned char* md)
{
SHA256_CTX context;
- if(!SHA256_Init(&context))
+ if (!SHA256_Init(&context))
return false;
- if(!SHA256_Update(&context, (unsigned char*)input, length))
+ if (!SHA256_Update(&context, (unsigned char*)input, length))
return false;
- if(!SHA256_Final(md, &context))
+ if (!SHA256_Final(md, &context))
return false;
return true;
}
int
-AsmCrypto::genRSASignValue(const char *privkey, const char * passwd, const unsigned char * msg, unsigned int len, unsigned char *sign,unsigned int *signlen)
+AsmCrypto::genRSASignValue(const char *privkey, const char * passwd, const unsigned char * msg, unsigned int len, unsigned char *sign, unsigned int *signlen)
{
return -1;
}
int
AsmCrypto::genB64Encode(const unsigned char *input, int inlen, unsigned char * output, int *outlen)
{
-#if 0
- EVP_ENCODE_CTX ctx;
- int t = 0;
- EVP_EncodeInit(&ctx);
- EVP_EncodeUpdate(&ctx, output,outlen,input,inlen);
- EVP_EncodeFinal(&ctx,output + *outlen, &t);
- *outlen += t -1;
-#else
BIO * bmem = NULL;
BIO * b64 = NULL;
BUF_MEM * bptr = NULL;
b64 = BIO_new(BIO_f_base64());
- if(b64 == NULL)
- {
+ if (b64 == NULL) {
_ERR("BIO_new failed \n");
return -1;
}
memcpy(output, bptr->data, bptr->length);
output[bptr->length] = 0;
*outlen = bptr->length;
- if(b64)
- {
+ if (b64)
BIO_free_all(b64);
- }
- //printf("outlen is %d, out is %s\n",*outlen, output);
-#endif
- for(int i =0; i < *outlen ; i++)
- {
- if(output[i] == '+')
- {
+
+ for (int i =0; i < *outlen ; i++) {
+ if (output[i] == '+') {
output[i] = '-';
- }
- else if(output[i] == '/')
- {
+ } else if (output[i] == '/') {
output[i] = '_';
- }
- else if(output[i] == '=')
- {
+ } else if (output[i] == '=') {
*outlen = i ;
output[i] = '\0';
break;
int npadChars = (inlen %4) == 0 ? 0 : (4 - (inlen%4));
unsigned char *base64 = (unsigned char *) malloc(inlen + npadChars);
- if(base64 == NULL)
+ if (base64 == NULL)
{
_ERR("malloc failed \n");
return -1;
}
memcpy(base64, input, inlen);
- for(int i =0; i < inlen ; i++)
+ for (int i =0; i < inlen ; i++)
{
- if(base64[i] == '-')
- {
+ if (base64[i] == '-') {
base64[i] = '+';
- }
- else if(base64[i] == '_')
- {
+ } else if (base64[i] == '_') {
base64[i] = '/';
}
}
- if(npadChars != 0)
+ if (npadChars != 0)
{
memset(base64 + inlen, '=', npadChars);
}
BIO * b64 = NULL;
BIO * bmem = NULL;
b64 = BIO_new(BIO_f_base64());
- if(b64 == NULL)
+ if (b64 == NULL)
{
free(base64);
_ERR("BIO_new failed");
}
BIO_set_flags(b64, BIO_FLAGS_BASE64_NO_NL);
bmem = BIO_new_mem_buf(base64, inlen + npadChars);
- if(bmem == NULL)
+ if (bmem == NULL)
{
_ERR("BIO_new_mem_buf failed");
BIO_free(b64);
}
bmem = BIO_push(b64, bmem);
*outlen = BIO_read(bmem, output, inlen + npadChars);
- if(*outlen <=0)
+ if (*outlen <=0)
{
BIO_free(b64);
free(base64);
_ERR("BIO_read failed. size or data error");
return -1;
}
- if(b64) {
+ if (b64) {
BIO_free_all(b64);
}
int ciphertext_len;
- if(!(ctx = EVP_CIPHER_CTX_new()))
+ if (!(ctx = EVP_CIPHER_CTX_new()))
{
_ERR("EVP_CIPHER_CTX_new() failed");
return -1;
}
- if(1 != EVP_EncryptInit_ex(ctx, EVP_aes_256_cbc(), NULL, key, iv))
+ if (1 != EVP_EncryptInit_ex(ctx, EVP_aes_256_cbc(), NULL, key, iv))
{
_ERR("EVP_EncryptInit_ex() failed");
return -1;
}
- if(1 != EVP_EncryptUpdate(ctx, ciphertext, &len, plaintext, plaintext_len))
+ if (1 != EVP_EncryptUpdate(ctx, ciphertext, &len, plaintext, plaintext_len))
{
_ERR("EVP_EncryptUpdate() failed");
return -1;
ciphertext_len = len;
- if(1 != EVP_EncryptFinal_ex(ctx, ciphertext + len, &len))
+ if (1 != EVP_EncryptFinal_ex(ctx, ciphertext + len, &len))
{
_ERR("EVP_EncryptFinal_ex() failed");
return -1;
int plaintext_len;
- if(!(ctx = EVP_CIPHER_CTX_new()))
+ if (!(ctx = EVP_CIPHER_CTX_new()))
{
_ERR("EVP_CIPHER_CTX_new() failed");
return -1;
}
- if(1 != EVP_DecryptInit_ex(ctx, EVP_aes_256_cbc(), NULL, key, iv))
+ if (1 != EVP_DecryptInit_ex(ctx, EVP_aes_256_cbc(), NULL, key, iv))
{
_ERR("EVP_DecryptInit_ex() failed");
return -1;
}
- if(1 != EVP_DecryptUpdate(ctx, plaintext, &len, ciphertext, ciphertext_len))
+ if (1 != EVP_DecryptUpdate(ctx, plaintext, &len, ciphertext, ciphertext_len))
{
_ERR("EVP_DecryptUpdate() failed");
return -1;
plaintext_len = len;
- if(1 != EVP_DecryptFinal_ex(ctx, plaintext + len, &len))
+ if (1 != EVP_DecryptFinal_ex(ctx, plaintext + len, &len))
{
_ERR("EVP_DecryptFinal_ex() failed");
return -1;
_INFO("ReadDERCertFile start");
FILE *fp = fopen(der_file_name, "r");
- if(fp == NULL)
+ if (fp == NULL)
return NULL;
X509 *pcert = NULL;
_der_cert_s *cert = (_der_cert_s*)(calloc(1, sizeof(_der_cert_s)));
int ret = __load_cert_from_x509(pcert, &cert);
- if(ret != 0) {
+ if (ret != 0) {
SAFE_DELETE(cert);
return NULL;
}
char *M = (char *) mem;
byte[2] = 0;
- for(i = 0; i < len; i+=2)
+ for (i = 0; i < len; i+=2)
{
byte[0] = str[i];
byte[1] = str[i+1];
// Create the Message Digest Context
- if(EVP_SUCCESS != EVP_DigestSignInit(mdctx, &pctx, EVP_sha256(), NULL, privKey)) {
+ if (EVP_SUCCESS != EVP_DigestSignInit(mdctx, &pctx, EVP_sha256(), NULL, privKey)) {
_ERR("EVP_DigestSignInit failed");
return -1;
}
/* Set padding algorithm */
- if(EVP_SUCCESS != EVP_PKEY_CTX_set_rsa_padding(pctx, RSA_PKCS1_PSS_PADDING)) {
+ if (EVP_SUCCESS != EVP_PKEY_CTX_set_rsa_padding(pctx, RSA_PKCS1_PSS_PADDING)) {
_ERR("EVP_PKEY_CTX_set_rsa_padding failed");
return -1;
}
_INFO("After EVP_PKEY_CTX_set_rsa_pss_saltlen with 32");
/* Set masking */
- if(EVP_SUCCESS != EVP_PKEY_CTX_set_rsa_mgf1_md(pctx, EVP_sha256())) {
+ if (EVP_SUCCESS != EVP_PKEY_CTX_set_rsa_mgf1_md(pctx, EVP_sha256())) {
_ERR("EVP_PKEY_CTX_set_rsa_padding failed");
return -1;
}
/* Call update with the message */
- if(EVP_SUCCESS != EVP_DigestSignUpdate(mdctx, message, m_len)) {
+ if (EVP_SUCCESS != EVP_DigestSignUpdate(mdctx, message, m_len)) {
_ERR("EVP_DigestSignUpdate failed");
return -1;
}
/* First call EVP_DigestSignFinal with a NULL sig parameter to obtain the length of the
* signature. Length is returned in slen */
size_t slen;
- if(EVP_SUCCESS != EVP_DigestSignFinal(mdctx, NULL, &slen)) {
+ if (EVP_SUCCESS != EVP_DigestSignFinal(mdctx, NULL, &slen)) {
_ERR("EVP_DigestSignFinal failed");
return -1;
}
//int slen = 0;
/* Obtain the signature */
- if(EVP_SUCCESS != EVP_DigestSignFinal(mdctx, sig, &slen)) {
+ if (EVP_SUCCESS != EVP_DigestSignFinal(mdctx, sig, &slen)) {
_ERR("EVP_DigestSignFinal failed");
SAFE_DELETE(sig);
return -1;
author_cert_hash = __get_pub_key_from_cert(author_cert);
_INFO("");
- if(author_cert_hash == NULL) {
+ if (author_cert_hash == NULL) {
pkgmgrinfo_pkginfo_destroy_certinfo(cert_handle);
return 0;
}
return NULL;
}
- if(certInfo->pkgId != NULL)
+ if (certInfo->pkgId != NULL) {
_INFO("AsmCrypto::getAppId:: pkgId = [%s]", certInfo->pkgId);
- else {
+ } else {
_INFO("AsmCrypto::getAppId:: pkgId NULL");
/*TODO For requests coming from remote device, we can not use pkgmgr to
* find out App-Id, instead Client Device's ASM must send it explicitly
_INFO("");
rsa = PEM_read_bio_RSAPrivateKey(bio, NULL, NULL, NULL);
- if(rsa == NULL) {
+ if (rsa == NULL) {
_ERR("BIO_new_mem_buf failed");
return NULL;
}
#define AUTH_TYPE_HAS_SETTINGS 0x0010
-typedef enum
-{
+typedef enum {
UAF_CMD_STATUS_OK = 0x00,
UAF_CMD_STATUS_ERR_UNKNOWN = 0x01,
UAF_CMD_STATUS_ACCESS_DENIED = 0x02,
UAF_CMD_STATUS_USER_CANCELLED = 0x05,
UAF_CMD_STATUS_CMD_NOT_SUPPORTED = 0x06,
UAF_CMD_STATUS_ATTESTATION_NOT_SUPPORTED = 0x07
-}UAF_AUTHNR_STATUS_CODE;
+} UAF_AUTHNR_STATUS_CODE;
typedef enum {
TLV_ASSRT_TYPE_REG,
} tlv_assertion_type_e;
/** Authenticator algorithms */
-typedef enum
-{
+typedef enum {
UAF_ALG_SIGN_SECP256R1_ECDSA_SHA256_RAW = 0x01,
UAF_ALG_SIGN_SECP256R1_ECDSA_SHA256_DER = 0x02,
UAF_ALG_SIGN_RSASSA_PSS_SHA256_RAW = 0x03,
UAF_ALG_SIGN_RSASSA_PSS_SHA256_DER = 0x04,
UAF_ALG_SIGN_SECP256K1_ECDSA_SHA256_RAW = 0x05,
UAF_ALG_SIGN_SECP256K1_ECDSA_SHA256_DER = 0x06
-}AUTHENTICATOR_ALGORITHM;
+} AUTHENTICATOR_ALGORITHM;
/** Public key representation format */
-typedef enum
-{
+typedef enum {
UAF_ALG_KEY_ECC_X962_RAW = 0x100,
UAF_ALG_KEY_ECC_X962_DER = 0x101,
UAF_ALG_KEY_RSA_2048_PSS_RAW = 0x102,
UAF_ALG_KEY_RSA_2048_PSS_DER = 0x103,
-}PUBLIC_KEY_FORMAT;
+} PUBLIC_KEY_FORMAT;
-typedef enum
-{
+typedef enum {
AUTHNR_2ND_FACTOR = 0x0001,
AUTHNR_ROAMING = 0x0002,
AUTHNR_STORE_KEYHANDLES_INSIDE = 0x0004,
AUTHNR_HAS_BUILTIN_SETTINGS_UI = 0x0010,
AUTHNR_REQUIRE_TAG_APPID = 0x0020,
AUTHNR_AT_LEAST_ONE_USER_ENROLLED = 0x0040
-}AUTHENTICATOR_TYPE;
+} AUTHENTICATOR_TYPE;
-typedef enum
-{
+typedef enum {
USER_VERIFY_PRESENCE = 0x01,
USER_VERIFY_FINGERPRINT = 0x02,
USER_VERIFY_PASSCODE = 0x04,
USER_VERIFY_HANDPRINT = 0x100,
USER_VERIFY_NONE = 0x200,
USER_VERIFY_ALL = 0x400
-}USER_VERIFICATION_METHOD;
+} USER_VERIFICATION_METHOD;
-typedef enum
-{
+typedef enum {
KEY_PROTECTION_SOFTWARE = 0x01,
KEY_PROTECTION_HARDWARE = 0x02,
KEY_PROTECTION_TEE = 0x04,
KEY_PROTECTION_SECURE_ELEMENT = 0x08,
KEY_PROTECTION_REMOTE_HANDLE = 0x10
-}KEY_PROTECTION_TYPE;
+} KEY_PROTECTION_TYPE;
/** Matcher protection types */
-typedef enum
-{
+typedef enum {
MATCHER_PROTECTION_SOFTWARE = 0x01,
MATCHER_PROTECTION_TEE = 0x02,
MATCHER_PROTECTION_ON_CHIP = 0x04
-}MATCHER_PROTECTION_TYPE;
+} MATCHER_PROTECTION_TYPE;
-typedef enum
-{
+typedef enum {
TRANSACTION_CONFIRMATION_DISPLAY_ANY = 0x01,
TRANSACTION_CONFIRMATION_DISPLAY_PRIVILEGED_SOFTWARE = 0x02,
TRANSACTION_CONFIRMATION_DISPLAY_TEE = 0x04,
TRANSACTION_CONFIRMATION_DISPLAY_HARDWARE = 0x08,
TRANSACTION_CONFIRMATION_DISPLAY_REMOTE = 0x10
-}TRANSACTION_CONFIRMATION_DISPLAY_TYPE;
+} TRANSACTION_CONFIRMATION_DISPLAY_TYPE;
typedef enum {
ATTACHMENT_HINT_INTERNAL = 0x01,
Buffer *khATok;
char *userVToken;
GList *khHList;/*List of char* */
-
} AuthenticateReq;
/*
class DisplayChar;
class Transaction {
-
public:
std::string getTransContent(void);
* https://fidoalliance.org/specs/fido-uaf-v1.0-ps-20141208/fido-uaf-asm-api-v1.0-ps-20141208.html#dictionary-authenticatein-members
*/
class AsmAuthRequest {
-
public:
~AsmAuthRequest(void);
* https://fidoalliance.org/specs/fido-uaf-v1.0-ps-20141208/fido-uaf-asm-api-v1.0-ps-20141208.html#dictionary-authenticateout-members
*/
class AsmAuthResponse {
-
public:
~AsmAuthResponse(void);
std::string __assertionScheme;
friend class AuthenticateState;
-
};
#endif //__ASM_AUTH_RESP_H__
* https://fidoalliance.org/specs/fido-uaf-v1.0-ps-20141208/fido-uaf-asm-api-v1.0-ps-20141208.html#dictionary-deregisterin-members
*/
class AsmDeregRequest {
-
public:
~AsmDeregRequest(void);
#include <vector>
class AsmDeregResponse {
-
public:
~AsmDeregResponse(void);
private:
AsmDeregResponse(void);
-
};
#endif //__ASM_DEREG_RESP_H__
#define ASMGETINFOREQUEST_H
class AsmGetInfoRequest {
-
public:
~AsmGetInfoRequest(void);
class GetRegsState;
class AppRegistration {
-
public:
~AppRegistration(void);
std::string getAppId(void);
* https://fidoalliance.org/specs/fido-uaf-v1.0-ps-20141208/fido-uaf-asm-api-v1.0-ps-20141208.html#dictionary-getregistrationsout-members
*/
class AsmGetRegsResponse {
-
public:
~AsmGetRegsResponse(void);
private:
std::vector<AppRegistration> __appRegList;
friend class GetRegsState;
-
};
#endif //__ASM_GET_REGS_RESP_H__
* https://fidoalliance.org/specs/fido-uaf-v1.0-ps-20141208/fido-uaf-asm-api-v1.0-ps-20141208.html#dictionary-registerin-members
*/
class AsmRegRequest {
-
public:
~AsmRegRequest(void);
* https://fidoalliance.org/specs/fido-uaf-v1.0-ps-20141208/fido-uaf-protocol-v1.0-ps-20141208.html#version-interface
*/
class AsmVersion {
-
public:
~AsmVersion(void);
* https://fidoalliance.org/specs/fido-uaf-v1.0-ps-20141208/fido-uaf-protocol-v1.0-ps-20141208.html#dictionary-extension-members
*/
class Extension {
-
public:
~Extension(void);
* https://fidoalliance.org/specs/fido-uaf-v1.0-ps-20141208/fido-uaf-asm-api-v1.0-ps-20141208.html#dictionary-asmrequest-members
*/
class AsmRequest {
-
public:
~AsmRequest(void);
class RegisterState;
class AuthenticateState;
class GetRegsState;
-
/*
* https://fidoalliance.org/specs/fido-uaf-v1.0-ps-20141208/fido-uaf-asm-api-v1.0-ps-20141208.html#dictionary-asmresponse-members
*/
class AsmResponse {
-
public:
~AsmResponse(void);
int getStatusCode(void);
void* getResponseData(void);
- std::vector<Extension*>* getExtensionList(void);
+ std::vector<Extension*> *getExtensionList(void);
private:
AsmResponse(void);
-
private:
int __statusCode;
void *__respData;
* https://fidoalliance.org/specs/fido-uaf-v1.0-ps-20141208/fido-uaf-asm-api-v1.0-ps-20141208.html#dictionary-getinfoout-members
*/
class GetInfoResponse {
-
public:
~GetInfoResponse(void);
- std::vector<AuthenticatorInfo*>* getAuthnrList(void);
+ std::vector<AuthenticatorInfo*> *getAuthnrList(void);
private:
GetInfoResponse(void);
private:
std::vector<AuthenticatorInfo*> *__authList;
-
};
#endif //__ASM_GET_INFO_RESP_H__
return __content;
}
-AsmAuthRequest::~AsmAuthRequest(void)
-{
-
-}
+AsmAuthRequest::~AsmAuthRequest(void) {}
std::string
AsmAuthRequest::getAppId(void)
return __fc;
}
-AsmAuthRequest::AsmAuthRequest(void)
-{
+AsmAuthRequest::AsmAuthRequest(void) {}
-}
#include "AsmAuthResponse.h"
#include <vector>
-AsmAuthResponse::~AsmAuthResponse(void)
-{
-
-}
+AsmAuthResponse::~AsmAuthResponse(void) {}
std::string
AsmAuthResponse::getAssertion(void)
return __assertionScheme;
}
-AsmAuthResponse::AsmAuthResponse(void)
-{
-
-}
+AsmAuthResponse::AsmAuthResponse(void) {}
#include "AsmDeregRequest.h"
#include <vector>
-AsmDeregRequest::~AsmDeregRequest(void)
-{
-
-}
+AsmDeregRequest::~AsmDeregRequest(void) {}
std::string
AsmDeregRequest::getAppId(void)
return __keyId;
}
-AsmDeregRequest::AsmDeregRequest(void)
-{
-
-}
+AsmDeregRequest::AsmDeregRequest(void) {}
#include "GetRegsState.h"
#include <vector>
-AppRegistration::~AppRegistration(void)
-{
-
-}
+AppRegistration::~AppRegistration(void) {}
std::string
AppRegistration::getAppId(void)
}
-AppRegistration::AppRegistration(void)
-{
+AppRegistration::AppRegistration(void) {}
-}
-
-AsmGetRegsResponse::~AsmGetRegsResponse(void)
-{
-
-}
+AsmGetRegsResponse::~AsmGetRegsResponse(void) {}
std::vector<AppRegistration>
AsmGetRegsResponse::getAppRegList(void)
return __appRegList;
}
-AsmGetRegsResponse::AsmGetRegsResponse(void)
-{
+AsmGetRegsResponse::AsmGetRegsResponse(void) {}
-}
#include "AsmRegRequest.h"
#include <vector>
-AsmRegRequest::~AsmRegRequest(void)
-{
-
-}
+AsmRegRequest::~AsmRegRequest(void) {}
std::string
AsmRegRequest::getServerChallenge(void)
{
__attType = -1;
}
-
-
-
#include "AsmRegResponse.h"
#include <vector>
-AsmRegResponse::AsmRegResponse(void)
-{
-
-}
+AsmRegResponse::AsmRegResponse(void) {}
-AsmRegResponse::~AsmRegResponse(void)
-{
-
-}
+AsmRegResponse::~AsmRegResponse(void) {}
std::string
AsmRegResponse::getAssertion(void)
if (__args != NULL) {
if (__requestType == "Register") {
delete static_cast<AsmRegRequest*>(__args);
- }
- else if (__requestType == "Authenticate") {
+ } else if (__requestType == "Authenticate") {
delete static_cast<AsmAuthRequest*>(__args);
- }
- else if (__requestType == "Deregister") {
+ } else if (__requestType == "Deregister") {
delete static_cast<AsmDeregRequest*>(__args);
}
}
return __customRequest;
}
-AsmVersion::~AsmVersion(void)
-{
-
-}
+AsmVersion::~AsmVersion(void) {}
int
AsmVersion::getMajor(void)
return __minor;
}
-AsmVersion::AsmVersion(void)
-{
-
-}
+AsmVersion::AsmVersion(void) {}
__extList = NULL;
}
-AsmResponse::~AsmResponse(void)
-{
-
-}
+AsmResponse::~AsmResponse(void) {}
int
AsmResponse::getStatusCode(void)
#include "AsmRequest.h"
#include "AuthnrTypes.h"
#include <glib.h>
-#if !GLIB_CHECK_VERSION (2, 31, 0)
+#if !GLIB_CHECK_VERSION(2, 31, 0)
#include <glib/gmacros.h>
#endif
#include <json-glib/json-glib.h>
class AsmResponse;
class JsonUtil {
-
public:
static AsmRequest* parseAsmRequestJson(const char *json);
static JsonBuilder* initComposer(int statusCode);
static char* finishComposer(JsonBuilder *builder);
-
};
strncpy(sub_str, str + i, chunk_size);
_INFO("log : [%s]", sub_str);
}
-
}
#define GET_ROOT_NODE(json) \
int i = 0;
for (; i < keyArrLen; i++) {
-
const char *keyId = json_array_get_string_element(keyArr, i);
if (keyId != NULL) {
_INFO("keyId is = [%s]", keyId);
int i = 0;
for (; i < tcArrLen; i++) {
-
JsonObject *tcObj = json_array_get_object_element(tcArr, i);
if (tcObj != NULL) {
-
std::string conTypeStr = getString(tcObj, "contentType");
std::string conStr = getString(tcObj, "content");
/*TODO: Add tcDisplayPNGCharacteristics when ASM UI is capable of image display*/
if ((conTypeStr.empty() == false)
&& (conStr.empty() == false)) {
-
Transaction *tc = new Transaction();
tc->__contentType = conTypeStr;
asmReq->__authenticatorIndex = json_object_get_int_member(rootObj, "authenticatorIndex");
- if(reqType == REQ_TYPE_GET_REGS) {
+ if (reqType == REQ_TYPE_GET_REGS) {
if (parser != NULL)
g_object_unref(parser);
argObj = json_object_get_object_member(rootObj, "args");
switch (reqType) {
-
case REQ_TYPE_REG:
asmReq->__args = parseAsmRequestArgReg(argObj);
break;
GList *authListIter = g_list_first(authList);
/*Supports one authenticator per authenticator*/
while (authListIter != NULL) {
-
AuthenticatorInfo *authInfo = (AuthenticatorInfo *)(authListIter->data);
/*AuthenticatorInfo*/
GList *attTypeList = authInfo->__attestationTypes;
if (attTypeList != NULL) {
-
GList *attTypeListIter = g_list_first(attTypeList);
if (g_list_length(attTypeListIter) > 0) {
-
json_builder_set_member_name(builder, "attestationTypes");
json_builder_begin_array(builder);
}
GList *extList = authInfo->__extList;
- if(extList != NULL) {
-
- if(g_list_length(extList) > 0) {
-
+ if (extList != NULL) {
+ if (g_list_length(extList) > 0) {
json_builder_set_member_name(builder, "supportedExtensionIDs");
json_builder_begin_array(builder);
if ((getInfoList != NULL) &&
(getInfoList->size() > 0)) {
-
_INFO("Auth Stub List is not NULL");
json_builder_set_member_name(builder, "responseData");
builder = initComposer(UAF_ASM_STATUS_ACCESS_DENIED);
if (regResp != NULL) {
-
json_builder_set_member_name(builder, "responseData");
json_builder_begin_object(builder);
std::vector<AppRegistration> appRegList = respData->getAppRegList();
- if(appRegList.empty() == false) {
+ if (appRegList.empty() == false) {
std::vector<AppRegistration>::iterator iter = appRegList.begin();
for (; iter != appRegList.end(); ++iter) {
-
json_builder_begin_object(builder);
AppRegistration appReg = *iter;
std::vector<std::string> keyIdList = appReg.getKeyIdList();
if (keyIdList.size() > 0) {
-
json_builder_set_member_name(builder, "keyIDs");
json_builder_begin_array(builder);
#include "StringTlvEncoder.h"
#include "BufferTlvEncoder.h"
-class AttBasicFullTlvEncoder : public ITlvEncoder {
-
+class AttBasicFullTlvEncoder:public ITlvEncoder {
public:
AttBasicFullTlvEncoder(void);
/*I/p: RegisterResp, O/p: TLV raw data*/
#include "StringTlvEncoder.h"
#include "BufferTlvEncoder.h"
-class AttBasicSurrTlvEncoder : public ITlvEncoder {
-
+class AttBasicSurrTlvEncoder:public ITlvEncoder {
public:
AttBasicSurrTlvEncoder(void);
/*I/p: RegisterResp, O/p: TLV raw data*/
class AuthAssertionInfoTlvEncoder
{
-
public:
AuthAssertionInfoTlvEncoder(void);
/*I/p: RegisterResp, O/p: TLV raw data*/
class AuthCountersInfoTlvEncoder
{
-
public:
AuthCountersInfoTlvEncoder(void);
/*I/p: RegisterResp, O/p: TLV raw data*/
#include "TlvData.h"
#include "ITlvEncoder.h"
-class BufferTlvEncoder : public ITlvEncoder
+class BufferTlvEncoder:public ITlvEncoder
{
-
public:
BufferTlvEncoder(void);
#include "StringTlvEncoder.h"
#include "BufferTlvEncoder.h"
-class DeRegReqTlvEncoder : public ITlvEncoder {
-
+class DeRegReqTlvEncoder:public ITlvEncoder {
public:
DeRegReqTlvEncoder(void);
/*I/p: RegisterResp, O/p: TLV raw data*/
#include "StringTlvEncoder.h"
#include "BufferTlvEncoder.h"
-class DeRegRespTlvEncoder : public ITlvEncoder {
-
+class DeRegRespTlvEncoder:public ITlvEncoder {
public:
DeRegRespTlvEncoder(void);
/*I/p: RegisterResp, O/p: TLV raw data*/
#include "TlvData.h"
-class GetInfoReqTlvEncoder : public ITlvEncoder {
-
+class GetInfoReqTlvEncoder:public ITlvEncoder {
public:
GetInfoReqTlvEncoder(void);
virtual ~GetInfoReqTlvEncoder(void);
/*I/p: Authenticator Specific data struct, O/p: TLV raw data*/
- virtual Buffer* encode(const void *authData);
+ virtual Buffer * encode(const void *authData);
/*I/p: TLV raw data, O/p: Authenticator Specific data struct*/
virtual void* decode(const unsigned char *rawData);
-
};
#endif /* GETINFO_REQ_TLV_ENCODER_H_ */
#include "IntTlvEncoder.h"
#include "StringTlvEncoder.h"
-class AuthMetaTlvEncoder : public ITlvEncoder
+class AuthMetaTlvEncoder:public ITlvEncoder
{
-
public:
AuthMetaTlvEncoder(void);
- virtual Buffer* encode(const void *authData);
+ virtual Buffer * encode(const void *authData);
virtual void* decode(const uint8_t *rawData);
StringTlvEncoder __strTlvEncoder;
};
-class TcDispPNGChTlvEncoder : public ITlvEncoder
+class TcDispPNGChTlvEncoder:public ITlvEncoder
{
-
public:
TcDispPNGChTlvEncoder(void);
- virtual Buffer* encode(const void *authData);
+ virtual Buffer * encode(const void *authData);
virtual void* decode(const uint8_t *rawData);
};
-class AuthInfoTlvEncoder : public ITlvEncoder
+class AuthInfoTlvEncoder:public ITlvEncoder
{
-
public:
AuthInfoTlvEncoder(void);
TcDispPNGChTlvEncoder __tcDispPNGChTlvEncoder;
};
-class GetInfoRespTlvEncoder : public ITlvEncoder
+class GetInfoRespTlvEncoder:public ITlvEncoder
{
-
public:
GetInfoRespTlvEncoder(void);
/*I/p: GetAuthInfoResp, O/p: TLV raw data*/
#include "Tlv.h"
class ITlvEncoder {
-
public:
virtual ~ITlvEncoder(void){}
/*I/p: Authenticator Specific data struct, O/p: TLV raw data*/
- virtual Buffer* encode(const void *authData) = 0;
+ virtual Buffer * encode(const void *authData) = 0;
/*I/p: TLV raw data, O/p: Authenticator Specific data struct*/
virtual void* decode(const uint8_t *rawData) = 0;
#include "TlvData.h"
#include "ITlvEncoder.h"
-class IntTlvEncoder : public ITlvEncoder
+class IntTlvEncoder:public ITlvEncoder
{
-
public:
IntTlvEncoder(void);
#include "IntTlvEncoder.h"
#include "StringTlvEncoder.h"
-class RegAssertionInfoTlvEncoder : public ITlvEncoder {
-
+class RegAssertionInfoTlvEncoder:public ITlvEncoder {
public:
RegAssertionInfoTlvEncoder(void);
/*I/p: RegisterResp, O/p: TLV raw data*/
#include "StringTlvEncoder.h"
#include "BufferTlvEncoder.h"
-class RegAuthAssertionTlvEncoder : public ITlvEncoder {
-
+class RegAuthAssertionTlvEncoder:public ITlvEncoder {
public:
RegAuthAssertionTlvEncoder(void);
/*I/p: RegisterResp, O/p: TLV raw data*/
#include "ITlvEncoder.h"
class RegCountersInfoTlvEncoder {
-
public:
RegCountersInfoTlvEncoder(void);
/*I/p: RegisterResp, O/p: TLV raw data*/
#include "StringTlvEncoder.h"
#include "BufferTlvEncoder.h"
-class RegAssertionTlvEncoder : public ITlvEncoder {
-
+class RegAssertionTlvEncoder:public ITlvEncoder {
public:
RegAssertionTlvEncoder(void);
/*I/p: RegAssertion, O/p: TLV raw data*/
#include "StringTlvEncoder.h"
#include "BufferTlvEncoder.h"
-class RegRespTlvEncoder : public ITlvEncoder {
-
+class RegRespTlvEncoder:public ITlvEncoder {
public:
RegRespTlvEncoder(void);
/*I/p: RegisterResp, O/p: TLV raw data*/
#include "StringTlvEncoder.h"
#include "BufferTlvEncoder.h"
-class SignAuthAssertionTlvEncoder : public ITlvEncoder {
-
+class SignAuthAssertionTlvEncoder:public ITlvEncoder {
public:
SignAuthAssertionTlvEncoder(void);
/*I/p: RegisterResp, O/p: TLV raw data*/
#include "StringTlvEncoder.h"
#include "BufferTlvEncoder.h"
-class SignReqTlvEncoder : public ITlvEncoder {
-
+class SignReqTlvEncoder:public ITlvEncoder {
public:
SignReqTlvEncoder(void);
/*I/p: RegisterResp, O/p: TLV raw data*/
#include "StringTlvEncoder.h"
#include "BufferTlvEncoder.h"
-class UserNameKhTlvEncoder : public ITlvEncoder {
-
+class UserNameKhTlvEncoder:public ITlvEncoder {
public:
UserNameKhTlvEncoder(void);
/*I/p: RegisterResp, O/p: TLV raw data*/
BufferTlvEncoder __buffTlvEncoder;
};
-class SignRespTlvEncoder : public ITlvEncoder {
-
+class SignRespTlvEncoder:public ITlvEncoder {
public:
SignRespTlvEncoder(void);
/*I/p: RegisterResp, O/p: TLV raw data*/
#include "StringTlvEncoder.h"
#include "BufferTlvEncoder.h"
-class SignedDataTlvEncoder : public ITlvEncoder {
-
+class SignedDataTlvEncoder:public ITlvEncoder {
public:
SignedDataTlvEncoder(void);
/*I/p: RegisterResp, O/p: TLV raw data*/
#include "TlvData.h"
#include "ITlvEncoder.h"
-class StringTlvEncoder : public ITlvEncoder
+class StringTlvEncoder:public ITlvEncoder
{
-
public:
StringTlvEncoder(void);
static ITlvEncoder* getTlvEncoderById(int id);
private:
TlvEncoderFactory(void);
- static std::map<int, ITlvEncoder*>* loadAllEncoders(void);
+ static std::map<int, ITlvEncoder*> *loadAllEncoders(void);
private:
static std::map<int, ITlvEncoder*> *__encoderTable;
__authData = NULL;
}
- TlvEncodable(const T *authData) : __authData(authData), __encoder(NULL){}
+ TlvEncodable(const T *authData) : __authData(authData), __encoder(NULL) {}
virtual ~TlvEncodable(void){}
#include "StringTlvEncoder.h"
#include "BufferTlvEncoder.h"
-class Uafv1KrdTlvEncoder : public ITlvEncoder {
-
+class Uafv1KrdTlvEncoder:public ITlvEncoder {
public:
Uafv1KrdTlvEncoder(void);
/*I/p: RegisterResp, O/p: TLV raw data*/
#include "AuthnrTypes.h"
#include "stdio.h"
-AttBasicFullTlvEncoder::AttBasicFullTlvEncoder(void)
-{
-
-}
+AttBasicFullTlvEncoder::AttBasicFullTlvEncoder(void) {}
Buffer *
AttBasicFullTlvEncoder::encode(const void *authData)
bool foundMember = false;
while(1) {
-
switch(child->tag) {
-
case TAG_SIGNATURE:
_INFO("");
getAttBasicFullInfo->sig = (Buffer*)__buffTlvEncoder.decode(rawData + rawIter);
_INFO("");
rawIter = rawIter + 2 + 2 + child->len;
- if(rawIter >= endIter)
+ if (rawIter >= endIter)
break;
SAFE_DELETE(child->val);
SAFE_DELETE(child->val);
SAFE_DELETE(child);
- if(foundMember == false) {
+ if (foundMember == false) {
free(getAttBasicFullInfo);
return NULL;
}
#include "AsmHelper.h"
#include "AuthnrTypes.h"
-AuthAssertionInfoTlvEncoder::AuthAssertionInfoTlvEncoder(void)
-{
-
-}
+AuthAssertionInfoTlvEncoder::AuthAssertionInfoTlvEncoder(void) {}
Buffer *
AuthAssertionInfoTlvEncoder::encode(const void *authData)
#include "AsmHelper.h"
#include "AuthnrTypes.h"
-AuthCountersInfoTlvEncoder::AuthCountersInfoTlvEncoder(void)
-{
-
-}
+AuthCountersInfoTlvEncoder::AuthCountersInfoTlvEncoder(void) {}
Buffer *
AuthCountersInfoTlvEncoder::encode(const void *authData)
#include "AsmHelper.h"
#include "AuthnrTypes.h"
-BufferTlvEncoder::BufferTlvEncoder(void)
-{
-
-}
+BufferTlvEncoder::BufferTlvEncoder(void) {}
Buffer *
BufferTlvEncoder::encode(const void *strTlv)
#include "AsmHelper.h"
#include "AuthnrTypes.h"
-DeRegReqTlvEncoder::DeRegReqTlvEncoder(void)
-{
-
-}
+DeRegReqTlvEncoder::DeRegReqTlvEncoder(void) {}
Buffer *
DeRegReqTlvEncoder::encode(const void *authData)
bool foundMember = false;
while(1) {
-
switch(child->tag) {
-
case TAG_AUTHENTICATOR_INDEX:
getDeRegReqInfo->authIdx = *(int*)__intTlvEncoder.decode(rawData + rawIter);
_INFO("authIdx [%d]", getDeRegReqInfo->authIdx);
}
rawIter = rawIter + 2 + 2 + child->len;
- if(rawIter >= endIter)
+ if (rawIter >= endIter)
break;
SAFE_DELETE(child->val);
SAFE_DELETE(child->val);
SAFE_DELETE(child);
- if(foundMember == false) {
+ if (foundMember == false) {
free(getDeRegReqInfo);
return NULL;
}
#include "AsmHelper.h"
#include "AuthnrTypes.h"
-DeRegRespTlvEncoder::DeRegRespTlvEncoder(void)
-{
-
-}
+DeRegRespTlvEncoder::DeRegRespTlvEncoder(void) {}
Buffer *
DeRegRespTlvEncoder::encode(const void *authData)
bool foundMember = false;
- if(child->tag == TAG_STATUS_CODE) {
+ if (child->tag == TAG_STATUS_CODE) {
getDeRegRespInfo->statusCode = *(int*)__intTlvEncoder.decode(rawData + rawIter);
_INFO("statusCode [%d]", getDeRegRespInfo->statusCode);
foundMember = true;
SAFE_DELETE(child->val);
SAFE_DELETE(child);
- if(foundMember == false) {
+ if (foundMember == false) {
free(getDeRegRespInfo);
return NULL;
}
#define GET_INT_FROM_BUFFER(val, ptr) do {\
if ((ptr == NULL)) {\
val = -1;\
- }\
- else {\
+ } else {\
val = *((int *)(ptr));\
}\
} while (0)
#define GET_STR_FROM_BUFFER(val, ptr) do {\
if ((ptr == NULL)) {\
val = NULL;\
- }\
- else {\
+ } else {\
val = (char *)(ptr);\
}\
} while (0)
}\
} while (0)
-AuthMetaTlvEncoder::AuthMetaTlvEncoder(void)
-{
-
-}
+AuthMetaTlvEncoder::AuthMetaTlvEncoder(void) {}
Buffer *
AuthMetaTlvEncoder::encode(const void *authData)
return meta;
}
-TcDispPNGChTlvEncoder::TcDispPNGChTlvEncoder(void)
-{
-
-}
+TcDispPNGChTlvEncoder::TcDispPNGChTlvEncoder(void) {}
Buffer *
TcDispPNGChTlvEncoder::encode(const void *authData)
return getTcDsipPngChInfo;
}
-AuthInfoTlvEncoder::AuthInfoTlvEncoder(void)
-{
-
-}
+AuthInfoTlvEncoder::AuthInfoTlvEncoder(void) {}
Buffer*
AuthInfoTlvEncoder::encode(const void *authData)
bool foundMember = false;
while (1) {
-
int attType = -1;
char *extId = NULL;
switch (child->tag) {
-
case TAG_AUTHENTICATOR_INDEX:
GET_INT_FROM_BUFFER(authInfo->__authenticatorIndex, (__intTlvEncoder.decode(rawData + rawIter)));
_INFO("__authenticatorIndex = [%d]", authInfo->__authenticatorIndex);
break;
case TAG_TC_DISPLAY_PNG_CHARACTERISTICS: {
-
DisplayTc *getTcDispPNGChInfo = (DisplayTc*)(__tcDispPNGChTlvEncoder.decode(rawData + rawIter));
- if(getTcDispPNGChInfo != NULL) {
+ if (getTcDispPNGChInfo != NULL) {
authInfo->__tcDisplayPNGCharacteristics = g_list_append(authInfo->__tcDisplayPNGCharacteristics,
getTcDispPNGChInfo);
getTcDispPNGChInfo = NULL;
default:
foundMember = false;
break;
-
}
rawIter = rawIter + 2 + 2 + child->len;
return authInfo;
}
-GetInfoRespTlvEncoder::GetInfoRespTlvEncoder(void)
-{
-
-}
+GetInfoRespTlvEncoder::GetInfoRespTlvEncoder(void) {}
Buffer *
GetInfoRespTlvEncoder::encode(const void *authData)
if (getInfoResp->authList != NULL) {
-
_INFO("GetInfoRespTlvEncoder::encode 6");
GList *authIter = g_list_first(getInfoResp->authList);
while (authIter != NULL) {
Buffer *metaBuff = __authMetaTlvEncoder.encode(auth->__meta);
if (metaBuff != NULL) {
-
_INFO("GetInfoRespTlvEncoder::encode 12");
/*1.4.3 TAG_AUTHENTICATOR_METADATA*/
tlv_builder_add_buffer(builder, TAG_AUTHENTICATOR_METADATA, metaBuff);
_INFO("GetInfoRespTlvEncoder::encode 14");
/*1.4.5 TAG_TC_DISPLAY_PNG_CHARACTERSTICS*/
/* TODO __tcDispPNGChTlvEncoder causing crash
- if(auth->__tcDisplayPNGCharacteristics != NULL) {
+ if (auth->__tcDisplayPNGCharacteristics != NULL) {
GList *iter = g_list_first(auth->__tcDisplayPNGCharacteristics);
while(iter != NULL) {
_INFO("GetInfoRespTlvEncoder::encode 19");
if (auth->__attestationTypes != NULL) {
-
GList *attIter = g_list_first(auth->__attestationTypes);
while (attIter != NULL) {
_INFO("GetInfoRespTlvEncoder::encode 20");
}
_INFO("GetInfoRespTlvEncoder::encode 22");
- if(auth->__extList != NULL) {
-
+ if (auth->__extList != NULL) {
GList *extIter = g_list_first(auth->__extList);
while(extIter != NULL) {
_INFO("GetInfoRespTlvEncoder::encode 23");
GetAuthInfoResp *getInfoResp = (GetAuthInfoResp*)calloc(1, sizeof(GetAuthInfoResp));
while (1) {
-
switch (child->tag) {
-
case TAG_STATUS_CODE:
getInfoResp->statusCode = *((int *)(__intTlvEncoder.decode(rawData + rawIter)));
_INFO("statusCode = [%d]", getInfoResp->statusCode);
#include "AsmHelper.h"
#include "AuthnrTypes.h"
-IntTlvEncoder::IntTlvEncoder(void)
-{
-
-}
+IntTlvEncoder::IntTlvEncoder(void) {}
Buffer *
IntTlvEncoder::encode(const void *intTlv)
int val = 0;
int i = 0;
for (i = 0; i < (tlv->len); i++) {
-
_INFO("tlv->val[i] = %d", tlv->val[i]);
int b_val = tlv->val[i] << (i * 8);
#include "AsmHelper.h"
#include "AuthnrTypes.h"
-RegAssertionInfoTlvEncoder::RegAssertionInfoTlvEncoder(void)
-{
-
-}
+RegAssertionInfoTlvEncoder::RegAssertionInfoTlvEncoder(void) {}
Buffer *
RegAssertionInfoTlvEncoder::encode(const void *authData)
#include "AuthnrTypes.h"
#include "stdio.h"
-RegAuthAssertionTlvEncoder::RegAuthAssertionTlvEncoder(void)
-{
-
-}
+RegAuthAssertionTlvEncoder::RegAuthAssertionTlvEncoder(void) {}
Buffer *
RegAuthAssertionTlvEncoder::encode(const void *authData)
/*1. TAG_UAFV1_REG_ASSERTION*/
tlv_builder_start_composite(builder, TAG_UAFV1_REG_ASSERTION);
- if(getRegAssertion->krd != NULL) {
+ if (getRegAssertion->krd != NULL) {
_INFO("");
Krd *getRegAssertionKrd = (Krd*)getRegAssertion->krd ;
SAFE_DELETE(getRegAssertionKrdTlv);
}
- if(getRegAssertion->attFull != NULL) {
-
+ if (getRegAssertion->attFull != NULL) {
_INFO("");
AttestationBasicFull *getAttBasicFullInfo = (AttestationBasicFull*)getRegAssertion->attFull;
Buffer *getAttBasicFullBuffInfo = (Buffer*)__attBasicFullTlvEncoder.encode(getAttBasicFullInfo);
SAFE_DELETE(attBasicFullBuff);
SAFE_DELETE(getAttBasicFullBuffInfo);
SAFE_DELETE(getAttBasicFullInfoTlv);
- }
- else if(getRegAssertion->attSur != NULL) {
-
+ } else if (getRegAssertion->attSur != NULL) {
_INFO("");
AttestationBasicSurrogate *getAttSurrInfo = (AttestationBasicSurrogate*)getRegAssertion->attSur;
Buffer *getAttBasicSurrInfoBuff = (Buffer*)__attBasicSurrTlvEncoder.encode(getAttSurrInfo);
SAFE_DELETE(attBasicSurrBuff);
SAFE_DELETE(getAttBasicSurrInfoBuff);
SAFE_DELETE(getAttBasicSurrInfoTlv);
- }
- else {
-
+ } else {
_ERR("No option of AttestationBasic is set");
SAFE_DELETE(builder);
return NULL;
RegAssertion *getRegAssertionInfo = ALLOC(RegAssertion);
while(1) {
-
switch(child->tag) {
-
case TAG_UAFV1_KRD:
_INFO("");
getRegAssertionInfo->krd = (Krd*)__uafv1KrdTlvEncoder.decode(rawData + rawIter);
_INFO("");
rawIter = rawIter + 2 + 2 + child->len;
- if(rawIter >= endIter)
+ if (rawIter >= endIter)
break;
SAFE_DELETE(child->val);
SAFE_DELETE(root);
_INFO("");
- if(foundMember == false) {
+ if (foundMember == false) {
_INFO("");
free(getRegAssertionInfo);
return NULL;
#include "AsmHelper.h"
#include "AuthnrTypes.h"
-RegCountersInfoTlvEncoder::RegCountersInfoTlvEncoder(void)
-{
-
-}
+RegCountersInfoTlvEncoder::RegCountersInfoTlvEncoder(void) {}
Buffer *
RegCountersInfoTlvEncoder::encode(const void *authData)
#include "AsmHelper.h"
#include "AuthnrTypes.h"
-RegAssertionTlvEncoder::RegAssertionTlvEncoder(void)
-{
-
-}
+RegAssertionTlvEncoder::RegAssertionTlvEncoder(void) {}
Buffer *
RegAssertionTlvEncoder::encode(const void *authData)
{
-
_INFO("RegAssertionTlvEncoder::encode start");
RET_IF_FAIL(authData != NULL, NULL);
tlv_builder_add_int8(builder, TAG_AUTHENTICATOR_INDEX, getRegReq->authIdx);
_INFO("RegAssertionTlvEncoder::encode 5");
- if(getRegReq->appId != NULL) {
+ if (getRegReq->appId != NULL) {
tlv_builder_add_string(builder, TAG_APPID, getRegReq->appId);
_INFO("RegAssertionTlvEncoder::encode 6");
}
tlv_builder_add_buffer(builder, TAG_KEYHANDLE_ACCESS_TOKEN, getRegReq->khAccessToken);
_INFO("RegAssertionTlvEncoder::encode 10");
- if(getRegReq->userVToken != NULL) {
+ if (getRegReq->userVToken != NULL) {
tlv_builder_add_string(builder, TAG_USERVERIFY_TOKEN, getRegReq->userVToken);
_INFO("RegAssertionTlvEncoder::encode 11");
}
while(1) {
switch(child->tag) {
-
case TAG_AUTHENTICATOR_INDEX:
_INFO("");
getRegReqInfo->authIdx = *(int*)__intTlvEncoder.decode(rawData + rawIter);
}
rawIter = rawIter + 2 + 2 + child->len;
- if(rawIter >= endIter)
+ if (rawIter >= endIter)
break;
SAFE_DELETE(child->val);
SAFE_DELETE(root->val);
SAFE_DELETE(root);
- if(foundMember == false) {
+ if (foundMember == false) {
free(getRegReqInfo);
return NULL;
}
#include "AsmHelper.h"
#include "AuthnrTypes.h"
-RegRespTlvEncoder::RegRespTlvEncoder(void)
-{
-
-}
+RegRespTlvEncoder::RegRespTlvEncoder(void) {}
Buffer *
RegRespTlvEncoder::encode(const void *authData)
/*1.3 end*/
/*1.4 TAG_KEYHANDLE*/
- if(getRegResp->kh != NULL) {
+ if (getRegResp->kh != NULL) {
tlv_builder_add_buffer(builder, TAG_KEYHANDLE, getRegResp->kh);
}
RegisterResp *getRegRespInfo = ALLOC(RegisterResp);
while(1) {
-
switch(child->tag) {
-
case TAG_STATUS_CODE:
_INFO("");
getRegRespInfo->statusCode = *(int*)__intTlvEncoder.decode(rawData + rawIter);
_INFO("");
rawIter = rawIter + 2 + 2 + child->len;
- if(rawIter >= endIter) {
+ if (rawIter >= endIter) {
_INFO("");
break;
}
SAFE_DELETE(root);
_INFO("");
- if(foundMember == false) {
+ if (foundMember == false) {
_INFO("");
free(getRegRespInfo);
return NULL;
#include "AsmHelper.h"
#include "AuthnrTypes.h"
-SignAuthAssertionTlvEncoder::SignAuthAssertionTlvEncoder(void)
-{
-
-}
+SignAuthAssertionTlvEncoder::SignAuthAssertionTlvEncoder(void) {}
Buffer *
SignAuthAssertionTlvEncoder::encode(const void *authData)
/*1. TAG_UAFV1_AUTH_ASSERTION*/
tlv_builder_start_composite(builder, TAG_UAFV1_AUTH_ASSERTION);
- if(getAuthAssertionInfo->sigData != NULL) {
-
+ if (getAuthAssertionInfo->sigData != NULL) {
/*1.2 TAG_UAFV1_SIGNED_DATA*/
SigData *getSigDataInfo = (SigData*)getAuthAssertionInfo->sigData;
}
while(1) {
-
switch(child->tag) {
-
case TAG_UAFV1_SIGNED_DATA:
getAuthAssInfo->sigData = (SigData*)__sigDataTlvEncoder.decode(rawData + rawIter);
foundMember = true;
break;
}
rawIter = rawIter + 2 + 2 + child->len;
- if(rawIter >= endIter)
+ if (rawIter >= endIter)
break;
SAFE_DELETE(child->val);
SAFE_DELETE(root->val);
SAFE_DELETE(root);
- if(foundMember == false) {
+ if (foundMember == false) {
free(getAuthAssInfo);
return NULL;
}
#include "AsmHelper.h"
#include "AuthnrTypes.h"
-SignReqTlvEncoder::SignReqTlvEncoder(void)
-{
-
-}
+SignReqTlvEncoder::SignReqTlvEncoder(void) {}
Buffer *
SignReqTlvEncoder::encode(const void *authData)
/*1.2 TAG_AUTHENTICATOR_INDEX*/
tlv_builder_add_int8(builder, TAG_AUTHENTICATOR_INDEX, getAuthReqInfo->authIdx);
- if(getAuthReqInfo->appId != NULL) {
-
+ if (getAuthReqInfo->appId != NULL) {
/*1.3 TAG_APPID*/
tlv_builder_add_string(builder, TAG_APPID, getAuthReqInfo->appId);
}
/*1.4 TAG_FINAL_CHALLENGE*/
tlv_builder_add_buffer(builder, TAG_FINAL_CHALLENGE, getAuthReqInfo->fch);
- if(getAuthReqInfo->tc != NULL) {
-
+ if (getAuthReqInfo->tc != NULL) {
/*1.5 TAG_TRANSACTION_CONTENT*/
tlv_builder_add_string(builder, TAG_TRANSACTION_CONTENT, getAuthReqInfo->tc);
}
/*1.6 TAG_KEYHANDLE_ACCESS_TOKEN*/
tlv_builder_add_buffer(builder, TAG_KEYHANDLE_ACCESS_TOKEN, getAuthReqInfo->khATok);
- if(getAuthReqInfo->userVToken != NULL) {
-
+ if (getAuthReqInfo->userVToken != NULL) {
/*1.7 TAG_USERVERIFY_TOKEN*/
tlv_builder_add_string(builder, TAG_USERVERIFY_TOKEN, getAuthReqInfo->userVToken);
}
- if(getAuthReqInfo->khHList != NULL) {
-
+ if (getAuthReqInfo->khHList != NULL) {
GList *getKhInfoIter = g_list_first(getAuthReqInfo->khHList);
while(getKhInfoIter != NULL) {
bool foundMember = false;
while(1) {
-
switch(child->tag) {
-
case TAG_AUTHENTICATOR_INDEX:
getAuthReqInfo->authIdx = *(int*)__intTlvEncoder.decode(rawData + rawIter);
foundMember = true;
case TAG_KEYHANDLE: {
char *getKeyHandle = (char*)__strTlvEncoder.decode(rawData + rawIter);
- if(getKeyHandle != NULL) {
+ if (getKeyHandle != NULL) {
getAuthReqInfo->khHList = g_list_append(getAuthReqInfo->khHList, getKeyHandle);
getKeyHandle = NULL;
}
}
rawIter = rawIter + 2 + 2 + child->len;
- if(rawIter >= endIter)
+ if (rawIter >= endIter)
break;
SAFE_DELETE(child->val);
SAFE_DELETE(root->val);
SAFE_DELETE(root);
- if(foundMember == false) {
+ if (foundMember == false) {
free(getAuthReqInfo);
return NULL;
}
#include "AsmHelper.h"
#include "AuthnrTypes.h"
-UserNameKhTlvEncoder::UserNameKhTlvEncoder(void)
-{
-
-}
+UserNameKhTlvEncoder::UserNameKhTlvEncoder(void) {}
Buffer *
UserNameKhTlvEncoder::encode(const void *authData)
bool foundMember = false;
while(1) {
-
switch(child->tag) {
-
case TAG_USERNAME:
getUsnKhInfo->userName = (char*)__strTlvEncoder.decode(rawData + rawIter);
foundMember = true;
break;
}
rawIter = rawIter + 2 + 2 + child->len;
- if(rawIter >= endIter)
+ if (rawIter >= endIter)
break;
SAFE_DELETE(child->val);
SAFE_DELETE(root->val);
SAFE_DELETE(root);
- if(foundMember == false) {
+ if (foundMember == false) {
free(getUsnKhInfo);
return NULL;
}
return getUsnKhInfo;
}
-SignRespTlvEncoder::SignRespTlvEncoder(void)
-{
-
-}
+SignRespTlvEncoder::SignRespTlvEncoder(void) {}
Buffer *
SignRespTlvEncoder::encode(const void *authData)
/*1.1 TAG_STATUS_CODE*/
tlv_builder_add_int16(builder, TAG_STATUS_CODE, getAuthRespInfo->statusCode);
- if(getAuthRespInfo->uKhList != NULL) {
-
+ if (getAuthRespInfo->uKhList != NULL) {
_INFO("SignRespTlvEncoder::uKhList");
GList *iter = g_list_first(getAuthRespInfo->uKhList);
while(iter != NULL) {
iter = iter->next;
}
- }
- else if(getAuthRespInfo->authAssertion != NULL) {
-
+ } else if (getAuthRespInfo->authAssertion != NULL) {
_INFO("SignRespTlvEncoder::authAssertion");
/*1.3 TAG_AUTHENTICATOR_ASSERTION*/
tlv_builder_add_buffer(builder, TAG_AUTHENTICATOR_ASSERTION, getAuthAssertionInfoBuff);
/*1.3 end*/
- }
- else {
-
+ } else {
_ERR("Neither UsernameKeyhandle List nor Authentication Assertion is set");
SAFE_DELETE(builder);
return NULL;
bool foundMember = false;
while(1) {
-
switch(child->tag) {
-
case TAG_STATUS_CODE:
getAuthRespInfo->statusCode = *(int*)__intTlvEncoder.decode(rawData + rawIter);
foundMember = true;
case TAG_USERNAME_AND_KEYHANDLE: {
_INFO("SignRespTlvEncoder::decode TAG_USERNAME_AND_KEYHANDLE");
UserNameKeyHandle *uKhInfo = (UserNameKeyHandle*)__uKhTlvEncoder.decode(rawData + rawIter);
- if(uKhInfo != NULL) {
+ if (uKhInfo != NULL) {
getAuthRespInfo->uKhList = g_list_append(getAuthRespInfo->uKhList, uKhInfo);
uKhInfo = NULL;
}
break;
}
rawIter = rawIter + 2 + 2 + child->len;
- if(rawIter >= endIter)
+ if (rawIter >= endIter)
break;
SAFE_DELETE(child->val);
SAFE_DELETE(root->val);
SAFE_DELETE(root);
- if(foundMember == false) {
+ if (foundMember == false) {
free(getAuthRespInfo);
return NULL;
}
#include "AsmHelper.h"
#include "AuthnrTypes.h"
-SignedDataTlvEncoder::SignedDataTlvEncoder(void)
-{
-
-}
+SignedDataTlvEncoder::SignedDataTlvEncoder(void) {}
Buffer *
SignedDataTlvEncoder::encode(const void *authData)
/*1.2.2 TAG_AAID*/
tlv_builder_add_string(builder, TAG_AAID, getSigDataInfo->aaid);
- if(getSigDataInfo->assrtInfo != NULL) {
-
+ if (getSigDataInfo->assrtInfo != NULL) {
Buffer *getAssertionInfoBuff = __assertionInfo.encode(getSigDataInfo->assrtInfo);
- if(getAssertionInfoBuff != NULL) {
-
+ if (getAssertionInfoBuff != NULL) {
/*1.2.3 TAG_ASSERTION_INFO*/
tlv_builder_add_buffer(builder, TAG_ASSERTION_INFO, getAssertionInfoBuff);
}
/*1.2.7 TAG_KEYID*/
tlv_builder_add_buffer(builder, TAG_KEYID, getSigDataInfo->keyId);
- if(getSigDataInfo->counter != NULL) {
-
+ if (getSigDataInfo->counter != NULL) {
Buffer *getCounterInfoBuff = __counterInfo.encode(getSigDataInfo->counter);
- if(getCounterInfoBuff != NULL) {
-
+ if (getCounterInfoBuff != NULL) {
/*1.2.8 TAG_COUNTERS*/
tlv_builder_add_buffer(builder, TAG_COUNTERS, getCounterInfoBuff);
}
bool foundMember = false;
while(1) {
-
switch(child->tag) {
-
case TAG_AAID:
getSigDataInfo->aaid = (char*)__strTlvEncoder.decode(rawData + rawIter);
foundMember = true;
}
rawIter = rawIter + 2 + 2 + child->len;
- if(rawIter >= endIter)
+ if (rawIter >= endIter)
break;
SAFE_DELETE(child->val);
SAFE_DELETE(root->val);
SAFE_DELETE(root);
- if(foundMember == false) {
+ if (foundMember == false) {
free(getSigDataInfo);
return NULL;
}
#include "AsmHelper.h"
#include "AuthnrTypes.h"
-StringTlvEncoder::StringTlvEncoder(void)
-{
-
-}
+StringTlvEncoder::StringTlvEncoder(void) {}
Buffer *
StringTlvEncoder::encode(const void *strTlv)
if (tlv->len > 0) {
tlv->val = (uint8_t *)calloc(1, tlv->len);
memcpy(tlv->val, tlv_buffer_in + 2 + 2, tlv->len);
-
}
_INFO("[%0002x][%d]", tlv->tag, tlv->len);
#include "AuthnrTypes.h"
#include "stdio.h"
-Uafv1KrdTlvEncoder::Uafv1KrdTlvEncoder(void)
-{
-
-}
+Uafv1KrdTlvEncoder::Uafv1KrdTlvEncoder(void) {}
Buffer *
Uafv1KrdTlvEncoder::encode(const void *authData)
/*1.2.2 TAG_AAID*/
tlv_builder_add_string(builder, TAG_AAID, getRegAssertionKrd->aaid);
- if(getRegAssertionKrd->assrtInfo != NULL) {
-
+ if (getRegAssertionKrd->assrtInfo != NULL) {
Buffer *assertionInfoBuff = __assertionInfo.encode(getRegAssertionKrd->assrtInfo);
- if(assertionInfoBuff != NULL) {
-
+ if (assertionInfoBuff != NULL) {
/*1.2.3 TAG_ASSERTION_INFO*/
tlv_builder_add_buffer(builder, TAG_ASSERTION_INFO, assertionInfoBuff);
}
/*1.2.5 TAG_KEYID*/
tlv_builder_add_buffer(builder, TAG_KEYID, getRegAssertionKrd->keyId);
- if(getRegAssertionKrd->counter != NULL) {
-
+ if (getRegAssertionKrd->counter != NULL) {
Buffer *countersInfoBuff = __countersInfo.encode(getRegAssertionKrd->counter);
- if(countersInfoBuff != NULL) {
-
+ if (countersInfoBuff != NULL) {
/*1.2.6 TAG_COUNTERS*/
tlv_builder_add_buffer(builder, TAG_COUNTERS, countersInfoBuff);
}
bool foundMember = false;
while(1) {
-
switch(child->tag) {
-
case TAG_AAID:
getKrdInfo->aaid = (char*)__strTlvEncoder.decode(rawData + rawIter);
_INFO("aaid [%s]", getKrdInfo->aaid);
}
rawIter = rawIter + 2 + 2 + child->len;
- if(rawIter >= endIter)
+ if (rawIter >= endIter)
break;
SAFE_DELETE(child->val);
SAFE_DELETE(root->val);
SAFE_DELETE(root);
- if(foundMember == false) {
+ if (foundMember == false) {
free(getKrdInfo);
return NULL;
}
AcUiAdaptor::getInstance()->__result = AC_UI_RESULT_USER_DENIED;
}
-
g_main_loop_quit(AcUiAdaptor::getInstance()->__mainLoop);
}
__result = -1;
bundle *b = bundle_create();
- if (type == PIN_AUTH_MODE_ENROLL)
+ if (type == PIN_AUTH_MODE_ENROLL) {
bundle_add_str(b, TC_UI_KEY_MODE, TC_UI_VAL_MODE_PIN_ENROLL);
- else if (type == PIN_AUTH_MODE_VERIFY) {
+ } else if (type == PIN_AUTH_MODE_VERIFY) {
bundle_add_str(b, TC_UI_KEY_MODE, TC_UI_VAL_MODE_PIN_VERIFY);
bundle_add_str(b, TC_UI_KEY_TOK, tok.c_str());
}
PinAuthUiAdaptor::getInstance()->__result = result;
g_main_loop_quit(PinAuthUiAdaptor::getInstance()->__mainLoop);
-
}
PinAuthUiAdaptor::PinAuthUiAdaptor(void)
TcUiAdaptor::getInstance()->__result = result;
g_main_loop_quit(TcUiAdaptor::getInstance()->__mainLoop);
-
}
TcUiAdaptor::TcUiAdaptor(void)
#include <string>
class AuthIndexHandler {
-
public:
static AuthIndexHandler *getInstance(void);
public:
static AuthManager* getInstance(void);
- std::vector<IAuthStub*>* getAuthStubList(auth_type_e type);
+ std::vector<IAuthStub*> *getAuthStubList(auth_type_e type);
IAuthStub* getAuthStub(int mappedIndex);
int setAuthStubCache(auth_type_e type, std::map<int, IAuthStub*> *stubCache);
#include "IAuthStub.h"
-class BAuthStub : public IAuthStub {
-
+class BAuthStub:public IAuthStub {
friend class BoundADProvider;
public:
Buffer* encodeRegisterRespone(RegAssertion *regAssrt, char **assrt_scheme);
Buffer* encodeSignRespone(AuthAssertion *authAssertion, char **assrt_scheme);
- virtual void shutDown(void)
- {
-
- }
+ virtual void shutDown(void) {}
private:
BAuthStub(void);
#include <glib.h>
#include <gmodule.h>
-class BoundADProvider : public IADProvider {
-
+class BoundADProvider:public IADProvider {
friend class AuthManager;
public:
virtual int init(void);
virtual auth_type_e getType(void);
virtual std::vector<IAuthStub*> *getAuthStubList(void);
virtual void setCache(std::map<int, IAuthStub*> *stubCache);
- virtual IAuthStub* getStubFromCache(int mappedIdx);
+ virtual IAuthStub *getStubFromCache(int mappedIdx);
virtual ~BoundADProvider(void);
private:
std::map<int, IAuthStub*> *__stubCache;
typedef std::map<int, IAuthStub*>::iterator AuthnrMapIter;
-
};
#endif /* _BADP_H_ */
#include "IADProvider.h"
#include <bluetooth.h>
-class BtAdProvider : public IADProvider {
+class BtAdProvider:public IADProvider {
friend class AuthManager;
public:
virtual int init(void);
virtual auth_type_e getType(void);
virtual std::vector<IAuthStub*> *getAuthStubList(void);
virtual void setCache(std::map<int, IAuthStub*> *stubCache);
- virtual IAuthStub* getStubFromCache(int mappedIdx);
+ virtual IAuthStub *getStubFromCache(int mappedIdx);
virtual ~BtAdProvider(void);
BtCon *__caller;
};
-class BtCon : public IAuthConnection {
+class BtCon:public IAuthConnection {
public:
BtCon(void);
~BtCon(void);
virtual int init(void *handle);
- virtual StringMap* sendReqSync(StringMap *reqData);
+ virtual StringMap * sendReqSync(StringMap *reqData);
virtual int shutdown(void);
virtual char* getInfo(void);
virtual auth_type_e getType(void) = 0;
virtual std::vector<IAuthStub*> *getAuthStubList(void) = 0;
virtual void setCache(std::map<int, IAuthStub*> *stubCache) = 0;
- virtual IAuthStub* getStubFromCache(int mappedIdx) = 0;
+ virtual IAuthStub *getStubFromCache(int mappedIdx) = 0;
- virtual ~IADProvider(){}
+ virtual ~IADProvider() {}
};
#endif /* _IADP_H_ */
~IAuthConnection(void){}
virtual int init(void *handle) = 0;
- virtual StringMap* sendReqSync(StringMap *reqData) = 0;
+ virtual StringMap * sendReqSync(StringMap *reqData) = 0;
virtual char *getInfo(void) = 0;
virtual int shutdown(void) = 0;
};
virtual int enroll(const char *opt) = 0;
virtual bool isEnrolled(void) = 0;
virtual int verify(const char *opt, const char *fch, char **vToken) = 0;
- virtual RegisterResp* processRegister(const RegisterReq *regReq) = 0;
- virtual AuthenticateResp* processAuthenticate(const AuthenticateReq *authnReq) = 0;
- virtual DeregResp* processDeregister(const DeregReq *deregReq) = 0;
+ virtual RegisterResp * processRegister(const RegisterReq *regReq) = 0;
+ virtual AuthenticateResp * processAuthenticate(const AuthenticateReq *authnReq) = 0;
+ virtual DeregResp * processDeregister(const DeregReq *deregReq) = 0;
virtual int openSettings(void) = 0;
- virtual Buffer* hash(const std::string& message) = 0;
- virtual Buffer* encodeRegisterRespone(RegAssertion *regAssrt, char **assrt_scheme) = 0;
- virtual Buffer* encodeSignRespone(AuthAssertion *authAssertion, char **assrt_scheme) = 0;
+ virtual Buffer * hash(const std::string& message) = 0;
+ virtual Buffer *encodeRegisterRespone(RegAssertion *regAssrt, char **assrt_scheme) = 0;
+ virtual Buffer *encodeSignRespone(AuthAssertion *authAssertion, char **assrt_scheme) = 0;
virtual void shutDown(void) = 0;
virtual ~IAuthStub(void){}
#include "IAuthConnection.h"
#include "BoundADProvider.h"
-class LocalCon : public IAuthConnection {
+class LocalCon:public IAuthConnection {
//friend class BoundADProvider;
public:
LocalCon(void) {}
~LocalCon(void) {}
- virtual int init(void *handle) {return -1;}
- StringMap* sendReqSync(StringMap *reqData) {return NULL;}
- virtual int shutdown(void) {return 0;}
- virtual char* getInfo(void) {return NULL;}
+ virtual int init(void *handle) {return -1; }
+ StringMap* sendReqSync(StringMap *reqData) {return NULL; }
+ virtual int shutdown(void) {return 0; }
+ virtual char* getInfo(void) {return NULL; }
private:
auth_plugin_handle_s *__pluginHandle;
};
#include "IAuthStub.h"
#include "IAuthConnection.h"
-class RAuthStub : public IAuthStub {
-
+class RAuthStub:public IAuthStub {
friend class IotADProvider;
friend class BleAdProvider;
friend class BtAdProvider;
class AsmRequest;
class RoamingUtil {
-
public:
static AsmRequest *createAuthReq(const char *tlvB64);
__this = tempThis;
return __this;
-
}
/*Maps the Auth Index reported by the Authenticator to the index used in ASM*/
std::vector<IStorageParcel*> *searchRes = AsmStorage::getInstance()->searchData(searchParcel);
if (searchRes != NULL && searchRes->size() > 0) {
-
_INFO("Previously mapped index");
std::vector<IStorageParcel*>::iterator searchResiter = searchRes->begin();
for (; searchResiter != searchRes->end(); ++searchResiter) {
-
IStorageParcel *resParcel = (IStorageParcel*)(*searchResiter);
int mappedIndex = authIndex;
}
} else {
-
_INFO("New index");
IStorageParcel *searchParcelInner = new AuthStorageParcel();
std::vector<IStorageParcel*> *searchResInner = AsmStorage::getInstance()->searchData(searchParcelInner);
if (searchResInner != NULL) {
-
std::vector<IStorageParcel*>::iterator searchResiter = searchResInner->begin();
for (; searchResiter != searchResInner->end(); ++searchResiter) {
-
IStorageParcel *resParcel = (IStorageParcel*)(*searchResiter);
int mappedIndex = authIndex;
_INFO("Mapped Index=[%d]", mappedIndex);
return mappedIndex;
}
-
}
-
}
_INFO("Mapped Index with error=[%d]", authIndex);
std::vector<IStorageParcel*> *searchRes = AsmStorage::getInstance()->searchData(searchParcel);
if (searchRes != NULL) {
-
std::vector<IStorageParcel*>::iterator searchResiter = searchRes->begin();
for (; searchResiter != searchRes->end(); ++searchResiter) {
-
IStorageParcel *resParcel = (IStorageParcel*)(*searchResiter);
int authIndex = mappedIndex;
_INFO("Real Index=[%d]", authIndex);
return authIndex;
}
-
}
_INFO("Real Index with error=[%d]", mappedIndex);
return mappedIndex;
}
-AuthIndexHandler::AuthIndexHandler(void)
-{
-
-}
-
-AuthIndexHandler::~AuthIndexHandler(void)
-{
+AuthIndexHandler::AuthIndexHandler(void) {}
-}
+AuthIndexHandler::~AuthIndexHandler(void) {}
{
std::vector<IADProvider*>::iterator adIter = __providerList.begin();
for (; adIter != __providerList.end(); ++adIter) {
-
IADProvider *pro = (IADProvider*)(*adIter);
IAuthStub *stub = pro->getStubFromCache(mappedIndex);
if (stub != NULL) {
_INFO("");
std::vector<IADProvider*>::iterator adIter = __providerList.begin();
for (; adIter != __providerList.end(); ++adIter) {
-
IADProvider *pro = (IADProvider*)(*adIter);
_INFO("");
return 0;
}
}
-
return -1;
}
_INFO("");
if (__cachedData->authList != NULL) {
-
_INFO("");
GList *authListIter = g_list_first(__cachedData->authList);
while (authListIter != NULL) {
-
_INFO("");
AuthenticatorInfo *authInfo = (AuthenticatorInfo*)(authListIter->data);
/*TODO: Find Device ID logic used by IoTCon*/
_INFO("");
authListIter = authListIter->next;
}
-
}
/*__cachedData->attach_hint = __pluginHandle->conn->attach_hint();*/
__cachedData->title = __pluginHandle->conn->title();
__cachedData->description = __pluginHandle->conn->description();
- }
-
- /*Resetting fields altered during last RA operation*/
- else if (__cachedData->authList != NULL) {
+ } else if (__cachedData->authList != NULL) { /*Resetting fields altered during last RA operation*/
_INFO("");
GList *authListIter = g_list_first(__cachedData->authList);
while (authListIter != NULL) {
bool
BAuthStub::isUserVerificationNeeded(void)
{
- if(__pluginHandle->user == NULL || __pluginHandle->user->is_uv_reqd == NULL) {
+ if (__pluginHandle->user == NULL || __pluginHandle->user->is_uv_reqd == NULL) {
return true;
}
bool
BAuthStub::hasAuthUi(void)
{
- if((__pluginHandle->user == NULL) ||
+ if ((__pluginHandle->user == NULL) ||
(__pluginHandle->user->enroll == NULL) ||
(__pluginHandle->user->verify == NULL)) {
_INFO("Auth does not have inbuilt UI");
_BEGIN;
RET_IF_FAIL(__pluginHandle != NULL, -1);
- if(__pluginHandle->user == NULL || __pluginHandle->user->enroll == NULL) {
-
+ if (__pluginHandle->user == NULL || __pluginHandle->user->enroll == NULL) {
_INFO("BAuthStub::enroll::__pluginHandle->user->enroll NULL");
RET_IF_FAIL(opt != NULL, -1);
-
char *appId = NULL;
char *aaid = NULL;
int res = _parse_enroll_request((char*)opt, &appId, &aaid);
int ret = -1;
std::string appIdStr(appId);
std::string tok = uiAd->enrollUser(appIdStr, &ret);
- if(tok.c_str() == NULL) {
+ if (tok.c_str() == NULL) {
_INFO("BAuthStub::enroll::token NULL");
SAFE_DELETE(appId);
SAFE_DELETE(aaid);
{
_BEGIN;
- if(__pluginHandle->user == NULL || __pluginHandle->user->verify == NULL) {
-
+ if (__pluginHandle->user == NULL || __pluginHandle->user->verify == NULL) {
_INFO("BAuthStub::verify::__pluginHandle->user->verify NULL");
_INFO("VERIFY TOKEN = [%s]", *vToken);
__pluginHandle->process->process(authReq->data, &authRespRaw);
return encodableResp.decode(authRespRaw);
-
- }
- else {
+ } else {
authReq = __pluginHandle->assrt->encode(TAG_UAFV1_REGISTER_CMD, regReq);
__pluginHandle->process->process(authReq->data, &authRespRaw);
__pluginHandle->process->process(authReq->data, &authRespRaw);
return encodableResp.decode(authRespRaw);
-
- }
- else {
+ } else {
authReq = __pluginHandle->assrt->encode(TAG_UAFV1_SIGN_CMD, authnReq);
__pluginHandle->process->process(authReq->data, &authRespRaw);
__pluginHandle->process->process(authReq->data, &authRespRaw);
return encodableResp.decode(authRespRaw);
-
- }
- else {
+ } else {
authReq = __pluginHandle->assrt->encode(TAG_UAFV1_DEREGISTER_CMD, deregReq);
__pluginHandle->process->process(authReq->data, &authRespRaw);
/*Defult handlers*/
if (__pluginHandle->hash == NULL) {
-
unsigned char digest[5000];
AsmCrypto::genHash256(message.c_str(), strlen(message.c_str()), digest);
_INFO("AuthenrStub::hash::digest generated is [%s]", digest);
_END;
return hashInfo;
-
}
Buffer*
/*Default handlers*/
if (__pluginHandle->assrt == NULL) {
-
TlvEncodable<RegAssertion> encodableRegAssrtn(regAssrt);
encodableRegAssrtn.setEncoder(EID_UAFV1_REG_ASSERTION_RESP);
_END;
return encodableRegAssrtn.encode();
-
- }
- else {
+ } else {
_END;
return __pluginHandle->assrt->encode(TAG_UAFV1_REG_ASSERTION, regAssrt);
}
/*Default handlers*/
if (__pluginHandle->assrt == NULL) {
-
_INFO("");
TlvEncodable<AuthAssertion> encodableSignAssrtn(authAssertion);
encodableSignAssrtn.setEncoder(EID_UAFV1_SIGN_ASSERTION_RESP);
_INFO("");
_END;
return encodableSignAssrtn.encode();
-
- }
- else {
+ } else {
_END;
return __pluginHandle->assrt->encode(TAG_UAFV1_AUTH_ASSERTION, authAssertion);
}
-
#include "BoundADProvider.h"
#include "AsmHelper.h"
#include "AuthnrTypes.h"
CATCH:
free(handle);
return NULL;
-
}
plugin_assrt_handle_s*
CATCH:
free(handle);
return NULL;
-
}
int
_INFO("Before g_dir_read_name loop");
while ((filename = g_dir_read_name(dir))) {
if (g_pattern_match_string(plugin_name_pattern, filename)) {
-
std::string fullPathName;
fullPathName += dirName.c_str();
fullPathName += filename;
/*Later, during setCache its overwritten by mappedIndex*/
__stubCache->insert(std::make_pair(auth_plugin->id, stub));
-
}
-
#include "BtAdProvider.h"
#include "IAuthConnection.h"
#include "BtCon.h"
}
_INFO("bluetooth ");
return stubList;
-
}
void
BtAdProvider::BtAdProvider(void)
{
__stubCache = NULL;
-
__waitLoop = NULL;
__isValidInst = false;
__isDiscovering = false;
-
#include "BtCon.h"
#include "BTRoamingKeys.h"
#include "AsmHelper.h"
int i = 0;
while (1) {
-
if (data->data[i] == RA_LEN_DELIM)
break;
if ((i == data->data_size) || (data->data[i] == '\0')) {
SAFE_DELETE(d_len_str);
} else {
-
pack = (char*)calloc(data->data_size, sizeof(char));
memcpy(pack, data->data, data->data_size);
-
#include "RAuthStub.h"
#include "AsmHelper.h"
#include "RoamingUtil.h"
/*Map AuthIndex to MappedIndex*/
if (getInfoResp->authList != NULL) {
-
GList *authListIter = g_list_first(getInfoResp->authList);
while (authListIter != NULL) {
AuthenticatorInfo *authInfo = (AuthenticatorInfo*)(authListIter->data);
authInfo->__isRoamingAuthenticator = TRUE;
authListIter = authListIter->next;
}
-
}
getInfoResp->attach_hint = ATTACHMENT_HINT_EXTERNAL;
_END;
return hashInfo;
-
}
Buffer*
AsmRequest*
RoamingUtil::createAuthReq(const char *tlvB64)
{
-
RET_IF_FAIL(tlvB64 != NULL, NULL);
unsigned char *tlvRaw = NULL;
AsmRequest *asmReq = new AsmRequest();
switch (tlv->tag) {
-
case TAG_UAFV1_GETINFO_CMD: {
_INFO("");
TlvEncodable<GetInfoReq> encodableReq;
SAFE_DELETE(tlv);
return NULL;
-
}
_INFO("");
_INFO("RoamingUtil compose 2");
if (resp->authList != NULL) {
-
_INFO("RoamingUtil compose 3");
GList *respAuthListIter = g_list_first(resp->authList);
-
while (respAuthListIter != NULL) {
-
_INFO("RoamingUtil compose 4");
AuthenticatorInfo *authInfo = (AuthenticatorInfo*)(respAuthListIter->data);
if (authInfo != NULL) {
/*B64 encode*/
return b64Encode(getinfoRespBuff->data, getinfoRespBuff->len);
-
}
char *
} StringProperty;
class IStorageParcel {
-
-public:
+public :
IStorageParcel(void){}
virtual ~IStorageParcel(void){}
virtual std::string getDBName(void) = 0;
};
-class AsmStorageParcel : public IStorageParcel {
-
+class AsmStorageParcel:public IStorageParcel {
public:
AsmStorageParcel(void);
std::string __dbName;
};
-class AuthStorageParcel : public IStorageParcel {
-
+class AuthStorageParcel:public IStorageParcel {
public:
AuthStorageParcel(void);
std::string __dbName;
};
-class SecretStorageParcel : public IStorageParcel {
-
+class SecretStorageParcel:public IStorageParcel {
public :
SecretStorageParcel(void);
#include "fido-client-ipc-stub.h"
class ClientListner {
-
public:
static ClientListner* getInstance(void);
int start(void);
class AsmResponse;
class AsmOp {
-
public:
virtual ~AsmOp(void);
virtual char* execute(void);
#include "AsmOp.h"
#include "AsmOpFactory.h"
-class AuthenticateOp : public AsmOp {
+class AuthenticateOp:public AsmOp {
public:
virtual char* execute(void);
~AuthenticateOp(void);
#include "AsmOp.h"
#include "AsmOpFactory.h"
-class DeregOp : public AsmOp {
-
+class DeregOp:public AsmOp {
public:
~DeregOp(void);
virtual char* execute(void);
#include "AsmOp.h"
#include "AsmOpFactory.h"
-class GetInfoOp : public AsmOp {
-
+class GetInfoOp:public AsmOp {
public:
~GetInfoOp(void);
#include "AsmOp.h"
#include "AsmOpFactory.h"
-class GetRegsOp : public AsmOp {
-
+class GetRegsOp:public AsmOp {
public:
~GetRegsOp(void);
virtual char* execute(void);
#include "AsmOp.h"
#include "AsmOpFactory.h"
-class OpenSettingOp : public AsmOp {
-
+class OpenSettingOp:public AsmOp {
public:
~OpenSettingOp(void);
virtual char* execute(void);
#include "AsmOpFactory.h"
#include <vector>
-class RegisterOp : public AsmOp {
+class RegisterOp:public AsmOp {
public:
~RegisterOp(void);
int initStates(void);
friend class AsmOpFactory;
-
-
};
__authStub = NULL;
}
-AsmOp::~AsmOp(void)
-{
-
-}
-
-
-
+AsmOp::~AsmOp(void) {}
else
return NULL;
- if(op != NULL)
+ if (op != NULL)
_INFO("op successfully created");
/*GetInfo does not need stub, because it needs to communicate with all*/
if (strcmp(req->getRequesttype().c_str(), STRING_OP_TYPE_GET_INFO) != 0) {
-
op->__authStub = NULL;
int mappedIndex = -1;
if (req->getCustomRequest() == NULL) {
if (getInfo != NULL) {
GList *aListOfStub = getInfo->authList;
if (aListOfStub != NULL) {
-
while (aListOfStub != NULL) {
-
AuthenticatorInfo *authInfo = (AuthenticatorInfo*)(aListOfStub->data);
//std::string devIdStr(authInfo->__devId);
if ((stubMapR != NULL) && (stubMapR->size() > 0)) {
AuthManager::getInstance()->setAuthStubCache(AUTH_TYPE_ROAMING, stubMapR);
}
-
}
_INFO("Cache done");
}
GList *aListOfStub = getInfo->authList;
if (aListOfStub != NULL) {
-
while (aListOfStub != NULL) {
-
AuthenticatorInfo *authInfo = (AuthenticatorInfo*)(aListOfStub->data);
// std::string devIdStr(authInfo->__devId);
int
AsmStorageParcel::getInt(IntProperty prop, int *val)
{
- if(prop == INT_PROP_ID) {
+ if (prop == INT_PROP_ID) {
*val = __id;
return SQLITE_OK;
}
- if(prop == INT_PROP_AUTH_IDX) {
+ if (prop == INT_PROP_AUTH_IDX) {
*val = __authIdx;
return SQLITE_OK;
}
int
AsmStorageParcel::setInt(IntProperty prop, int val)
{
- if(prop == INT_PROP_ID) {
+ if (prop == INT_PROP_ID) {
__id = val;
return SQLITE_OK;
}
- if(prop == INT_PROP_AUTH_IDX) {
+ if (prop == INT_PROP_AUTH_IDX) {
__authIdx = val;
return SQLITE_OK;
}
int
AsmStorageParcel::getString(StringProperty prop, char **val)
{
- if(prop == STR_PROP_CALLER_ID) {
+ if (prop == STR_PROP_CALLER_ID) {
*val = strdup(__callerId.c_str());
return SQLITE_OK;
}
- if(prop == STR_PROP_APP_ID) {
+ if (prop == STR_PROP_APP_ID) {
*val = strdup(__appId.c_str());
return SQLITE_OK;
}
- if(prop == STR_PROP_KEY_HANDLE) {
+ if (prop == STR_PROP_KEY_HANDLE) {
*val = strdup(__keyHandle.c_str());
return SQLITE_OK;
}
- if(prop == STR_PROP_KEY_ID) {
+ if (prop == STR_PROP_KEY_ID) {
*val = strdup(__keyId.c_str());
return SQLITE_OK;
}
- if(prop == STR_PROP_TIME) {
+ if (prop == STR_PROP_TIME) {
*val = strdup(__ts.c_str());
return SQLITE_OK;
}
int
AsmStorageParcel::setString(StringProperty prop, const std::string& val)
{
- if(prop == STR_PROP_CALLER_ID) {
+ if (prop == STR_PROP_CALLER_ID) {
__callerId = val;
return SQLITE_OK;
}
- if(prop == STR_PROP_APP_ID) {
+ if (prop == STR_PROP_APP_ID) {
__appId = val;
return SQLITE_OK;
}
- if(prop == STR_PROP_KEY_HANDLE) {
+ if (prop == STR_PROP_KEY_HANDLE) {
__keyHandle = val;
return SQLITE_OK;
}
- if(prop == STR_PROP_KEY_ID) {
+ if (prop == STR_PROP_KEY_ID) {
__keyId = val;
return SQLITE_OK;
}
- if(prop == STR_PROP_TIME) {
+ if (prop == STR_PROP_TIME) {
__ts = val;
return SQLITE_OK;
}
int
AuthStorageParcel::getInt(IntProperty prop, int *val)
{
- if(prop == INT_PROP_AUTH_ID) {
+ if (prop == INT_PROP_AUTH_ID) {
*val = __authIndex;
return SQLITE_OK;
}
- if(prop == INT_PROP_MAPPED_AUTH_ID) {
+ if (prop == INT_PROP_MAPPED_AUTH_ID) {
*val = __mappedIndex;
return SQLITE_OK;
}
int
AuthStorageParcel::setInt(IntProperty prop, int val)
{
- if(prop == INT_PROP_AUTH_ID) {
+ if (prop == INT_PROP_AUTH_ID) {
__authIndex = val;
return SQLITE_OK;
}
- if(prop == INT_PROP_MAPPED_AUTH_ID) {
+ if (prop == INT_PROP_MAPPED_AUTH_ID) {
__mappedIndex = val;
return SQLITE_OK;
}
int
AuthStorageParcel::getString(StringProperty prop, char **val)
{
- if(prop == STR_PROP_DEV_ID) {
+ if (prop == STR_PROP_DEV_ID) {
if (__devId == "" || __devId.empty() == true)
return SQLITE_ERROR;
return SQLITE_OK;
}
- if(prop == STR_PROP_AAID) {
+ if (prop == STR_PROP_AAID) {
if (__aaid == "" || __aaid.empty() == true)
return SQLITE_ERROR;
int
AuthStorageParcel::setString(StringProperty prop, const std::string& val)
{
- if(prop == STR_PROP_DEV_ID) {
+ if (prop == STR_PROP_DEV_ID) {
__devId = val;
return SQLITE_OK;
}
- if(prop == STR_PROP_AAID) {
+ if (prop == STR_PROP_AAID) {
__aaid = val;
return SQLITE_OK;
}
int
SecretStorageParcel::setInt(IntProperty prop, int val)
{
- if(prop == INT_PROP_UID) {
+ if (prop == INT_PROP_UID) {
__uid = val;
return SQLITE_OK;
}
int
SecretStorageParcel::getInt(IntProperty prop, int *val)
{
- if(prop == INT_PROP_UID) {
+ if (prop == INT_PROP_UID) {
*val = __uid;
return SQLITE_OK;
}
int
SecretStorageParcel::setString(StringProperty prop, const std::string &val)
{
- if(prop == STR_PROP_AAID) {
+ if (prop == STR_PROP_AAID) {
__aaid = val;
return SQLITE_OK;
}
- if(prop == STR_PROP_DEV_ID) {
+ if (prop == STR_PROP_DEV_ID) {
__devId = val;
return SQLITE_OK;
}
- if(prop == STR_PROP_SECRET1) {
+ if (prop == STR_PROP_SECRET1) {
__secret1 = val;
return SQLITE_OK;
}
- if(prop == STR_PROP_SECRET2) {
+ if (prop == STR_PROP_SECRET2) {
__secret2 = val;
return SQLITE_OK;
}
int
SecretStorageParcel::getString(StringProperty prop, char **val)
{
- if(prop == STR_PROP_AAID) {
- if(__aaid == "" || __aaid.empty() == true)
+ if (prop == STR_PROP_AAID) {
+ if (__aaid == "" || __aaid.empty() == true)
return SQLITE_ERROR;
*val = strdup(__aaid.c_str());
return SQLITE_OK;
}
- if(prop == STR_PROP_DEV_ID) {
- if(__devId == "" || __devId.empty() == true)
+ if (prop == STR_PROP_DEV_ID) {
+ if (__devId == "" || __devId.empty() == true)
return SQLITE_ERROR;
*val = strdup(__devId.c_str());
return SQLITE_OK;
}
- if(prop == STR_PROP_SECRET1) {
- if(__secret1 == "" || __secret1.empty() == true)
+ if (prop == STR_PROP_SECRET1) {
+ if (__secret1 == "" || __secret1.empty() == true)
return SQLITE_ERROR;
*val = strdup(__secret1.c_str());
return SQLITE_OK;
}
- if(prop == STR_PROP_SECRET2) {
- if(__secret2 == "" || __secret2.empty() == true)
+ if (prop == STR_PROP_SECRET2) {
+ if (__secret2 == "" || __secret2.empty() == true)
return SQLITE_ERROR;
*val = strdup(__secret2.c_str());
const char *query = NULL;
char *dbPath = NALLOC(512, char);
- if(dbName == FIDO_ASM) {
+ if (dbName == FIDO_ASM) {
query = DB_QUERY_CREATE_TABLE_ASM;
snprintf(dbPath, 512 - 1, "%s", ASM_DB_PATH);
- }
- else if(dbName == FIDO_AUTH) {
+ } else if (dbName == FIDO_AUTH) {
query = DB_QUERY_CREATE_TABLE_AUTH;
snprintf(dbPath, 512 - 1, "%s", AUTH_DB_PATH);
- }
- else if(dbName == FIDO_SECRET) {
+ } else if (dbName == FIDO_SECRET) {
query = DB_QUERY_CREATE_TABLE_SECRET;
snprintf(dbPath, 512 - 1, "%s", SECRET_DB_PATH);
- }
- else {
+ } else {
SAFE_DELETE(dbPath);
return NULL;
}
{
_INFO("%s", dbName.c_str());
char *dbPath = NALLOC(512, char);
- if(dbName == FIDO_ASM) {
+ if (dbName == FIDO_ASM) {
snprintf(dbPath, 512 - 1, "%s", ASM_DB_PATH);
- }
- else if(dbName == FIDO_AUTH) {
+ } else if (dbName == FIDO_AUTH) {
snprintf(dbPath, 512 - 1, "%s", AUTH_DB_PATH);
- }
- else if(dbName == FIDO_SECRET) {
+ } else if (dbName == FIDO_SECRET) {
snprintf(dbPath, 512 - 1, "%s", SECRET_DB_PATH);
- }
- else {
+ } else {
SAFE_DELETE(dbPath);
return NULL;
}
const std::string& ts = currentTime;
- if(authIdx == -1 || callerId == "" || appId == "" ||keyId == "" ||ts == "") {
+ if (authIdx == -1 || callerId == "" || appId == "" ||keyId == "" ||ts == "") {
_ERR("One or more fields of the Asm parcel are not set properly");
closeDBHandle(dbHandle);
return SQLITE_ERROR;
}
- if(keyHandle.empty() == true) {
+ if (keyHandle.empty() == true) {
snprintf(query, BUFFLEN, "INSERT INTO ASMKEYS(auth_idx, caller_id, app_id, key_id, time_stamp) "
"VALUES (%d, \'%s\', \'%s\', \'%s\', \'%s\');",
authIdx, callerId.c_str(), appId.c_str(), keyId.c_str(), ts.c_str());
- }
- else {
+ } else {
snprintf(query, BUFFLEN, "INSERT INTO ASMKEYS(auth_idx, caller_id, app_id, key_handle, key_id, time_stamp) "
"VALUES (%d, \'%s\', \'%s\', \'%s\', \'%s\', \'%s\');",
authIdx, callerId.c_str(), appId.c_str(), keyHandle.c_str(), keyId.c_str(), ts.c_str());
}
- }
-
- else if(dbName == FIDO_AUTH) {
+ } else if (dbName == FIDO_AUTH) {
/*Device Id, AAID, AuthIndex taken from input*/
/*MappedIndex is auto-incremented*/
parcel->getString(STR_PROP_DEV_ID, &devId);
parcel->getString(STR_PROP_AAID, &aaid);
- if((devId == NULL) || (aaid == NULL) || (authIndex < 0)) {
+ if ((devId == NULL) || (aaid == NULL) || (authIndex < 0)) {
_ERR("One or more fields of the Auth parcel are not set properly");
_INFO("[%s][%s][%d]", devId, aaid, authIndex);
closeDBHandle(dbHandle);
"INSERT INTO AUTHLIST(auth_index, device_id, aaid, mapped_index) VALUES (%d, \'%s\', \'%s\', %d);",
authIndex, devId, aaid, mappedIndex);
_INFO("%s", query);
- }
-
- else if(dbName == FIDO_SECRET) {
+ } else if (dbName == FIDO_SECRET) {
int uid = -1;
char *aaid = NULL;
char *devId = NULL;
parcel->getString(STR_PROP_SECRET1, &secret1);
parcel->getString(STR_PROP_SECRET2, &secret2);
- if(uid == -1 || aaid == NULL || devId == NULL || secret1 == NULL) {
+ if (uid == -1 || aaid == NULL || devId == NULL || secret1 == NULL) {
_ERR("One or more fields of the Secret parcel are not set properly");
closeDBHandle(dbHandle);
return SQLITE_ERROR;
}
- if(secret2 == NULL) {
+ if (secret2 == NULL) {
snprintf(query, BUFFLEN,
"INSERT INTO SECRET(aaid, device_id, uid, secret_1) VALUES (\'%s\', \'%s\', %d, \'%s\');",
aaid, devId, uid, secret1);
- }
- else {
+ } else {
snprintf(query, BUFFLEN,
"INSERT INTO SECRET(aaid, device_id, uid, secret_1, secret_2) VALUES (\'%s\', \'%s\', %d, \'%s\', \'%s\');",
aaid, devId, uid, secret1, secret2);
for(std::vector<IStorageParcel*>::iterator it = parcel->begin(); it != parcel->end(); it++) {
ret = insertData(*it);
- if(ret != SQLITE_OK) {
+ if (ret != SQLITE_OK) {
_INFO("%d th Record not inserted/already exists", i+1);
- }
- else {
+ } else {
_INFO("%d th Record inserted successfully", i+1);
}
i++;
int itr = 0;
const char *empty = "";
- if(dbName == FIDO_ASM) {
+ if (dbName == FIDO_ASM) {
IStorageParcel *parcel = new AsmStorageParcel();
- if(itr < argc) {
- if(argv[itr] == NULL)
+ if (itr < argc) {
+ if (argv[itr] == NULL)
argv[itr] = (char*)empty;
parcel->setInt(INT_PROP_ID, atoi(argv[0]));
}
itr++;
- if(itr < argc) {
- if(argv[itr] == NULL)
+ if (itr < argc) {
+ if (argv[itr] == NULL)
argv[itr] = (char*)empty;
parcel->setInt(INT_PROP_AUTH_IDX, atoi(argv[1]));
}
itr++;
- if(itr < argc) {
- if(argv[itr] == NULL)
+ if (itr < argc) {
+ if (argv[itr] == NULL)
argv[itr] = (char*)empty;
parcel->setString(STR_PROP_CALLER_ID, argv[2]);
}
itr++;
- if(itr < argc) {
- if(argv[itr] == NULL)
+ if (itr < argc) {
+ if (argv[itr] == NULL)
argv[itr] = (char*)empty;
parcel->setString(STR_PROP_APP_ID, argv[3]);
}
itr++;
- if(itr < argc) {
- if(argv[itr] == NULL)
+ if (itr < argc) {
+ if (argv[itr] == NULL)
argv[itr] = (char*)empty;
parcel->setString(STR_PROP_KEY_HANDLE, argv[4]);
}
itr++;
- if(itr < argc) {
- if(argv[itr] == NULL)
+ if (itr < argc) {
+ if (argv[itr] == NULL)
argv[itr] = (char*)empty;
parcel->setString(STR_PROP_KEY_ID, argv[5]);
_INFO("AsmStorage::searchItemCb:: key_id = [%s]", argv[5]);
}
itr++;
- if(itr < argc) {
- if(argv[itr] == NULL)
+ if (itr < argc) {
+ if (argv[itr] == NULL)
argv[itr] = (char*)empty;
parcel->setString(STR_PROP_TIME, argv[6]);
}
cbData->resList->push_back(parcel);
return SQLITE_OK;
-
- }
-
- else if(dbName == FIDO_AUTH) {
+ } else if (dbName == FIDO_AUTH) {
IStorageParcel *parcel = new AuthStorageParcel();
if ((argc >= 1) && (argv[1] != NULL))
cbData->resList->push_back(parcel);
return SQLITE_OK;
- }
-
- else if(dbName == FIDO_SECRET) {
+ } else if (dbName == FIDO_SECRET) {
IStorageParcel *parcel = new SecretStorageParcel();
- if(itr < argc) {
- if(argv[itr] == NULL)
+ if (itr < argc) {
+ if (argv[itr] == NULL)
argv[itr] = (char*)empty;
parcel->setInt(INT_PROP_ID, atoi(argv[0]));
}
itr++;
- if(itr < argc) {
- if(argv[itr] == NULL)
+ if (itr < argc) {
+ if (argv[itr] == NULL)
argv[itr] = (char*)empty;
parcel->setString(STR_PROP_AAID, argv[1]);
}
itr++;
- if(itr < argc) {
- if(argv[itr] == NULL)
+ if (itr < argc) {
+ if (argv[itr] == NULL)
argv[itr] = (char*)empty;
parcel->setString(STR_PROP_DEV_ID, argv[2]);
}
itr++;
- if(itr < argc) {
- if(argv[itr] == NULL)
+ if (itr < argc) {
+ if (argv[itr] == NULL)
argv[itr] = (char*)empty;
parcel->setInt(INT_PROP_UID, atoi(argv[3]));
}
itr++;
- if(itr < argc) {
- if(argv[itr] == NULL)
+ if (itr < argc) {
+ if (argv[itr] == NULL)
argv[itr] = (char*)empty;
parcel->setString(STR_PROP_SECRET1, argv[4]);
}
itr++;
- if(itr < argc) {
- if(argv[itr] == NULL)
+ if (itr < argc) {
+ if (argv[itr] == NULL)
argv[itr] = (char*)empty;
parcel->setString(STR_PROP_SECRET2, argv[5]);
}
SearchCbData cbData;
- if(dbName == FIDO_ASM) {
+ if (dbName == FIDO_ASM) {
int id = -1;
int authIdx = -1;
snprintf(query, BUFFLEN, "SELECT * FROM ASMKEYS WHERE ");
bool isAnd = false;
- if(id != -1) {
+ if (id != -1) {
snprintf(q, BUFFLEN, "id=%d", id);
strncat(query, q, sizeof(query)-strlen(query)-1);
isAnd = true;
}
- if(authIdx != -1) {
- if(isAnd == true) {
+ if (authIdx != -1) {
+ if (isAnd == true) {
snprintf(q, BUFFLEN, " AND auth_idx=%d", authIdx);
strncat(query, q, sizeof(query)-strlen(query)-1);
- }
- else {
+ } else {
snprintf(q, BUFFLEN, "auth_idx=%d", authIdx);
strncat(query, q, sizeof(query)-strlen(query)-1);
isAnd = true;
}
}
- if(callerId != "") {
- if(isAnd == true) {
+ if (callerId != "") {
+ if (isAnd == true) {
snprintf(q, BUFFLEN, " AND caller_id=\'%s\'", callerId.c_str());
strncat(query, q, sizeof(query)-strlen(query)-1);
- }
- else {
+ } else {
snprintf(q, BUFFLEN, "caller_id=\'%s\'", callerId.c_str());
strncat(query, q, sizeof(query)-strlen(query)-1);
isAnd = true;
}
}
- if(appId != "") {
- if(isAnd == true) {
+ if (appId != "") {
+ if (isAnd == true) {
snprintf(q, BUFFLEN, " AND app_id=\'%s\'", appId.c_str());
strncat(query, q, sizeof(query)-strlen(query)-1);
- }
- else {
+ } else {
snprintf(q, BUFFLEN, "app_id=\'%s\'", appId.c_str());
strncat(query, q, sizeof(query)-strlen(query)-1);
isAnd = true;
}
}
- if(keyHandle != "") {
- if(isAnd == true) {
+ if (keyHandle != "") {
+ if (isAnd == true) {
snprintf(q, BUFFLEN, " AND key_handle=\'%s\'", keyHandle.c_str());
strncat(query, q, sizeof(query)-strlen(query)-1);
- }
- else {
+ } else {
snprintf(q, BUFFLEN, "key_handle=\'%s\'", keyHandle.c_str());
strncat(query, q, sizeof(query)-strlen(query)-1);
isAnd = true;
}
}
- if(keyId != "") {
- if(isAnd == true) {
+ if (keyId != "") {
+ if (isAnd == true) {
snprintf(q, BUFFLEN, " AND key_id=\'%s\'", keyId.c_str());
strncat(query, q, sizeof(query)-strlen(query)-1);
- }
- else {
+ } else {
snprintf(q, BUFFLEN, "key_id=\'%s\'", keyId.c_str());
strncat(query, q, sizeof(query)-strlen(query)-1);
isAnd = true;
snprintf(q, BUFFLEN, ";");
strncat(query, q, sizeof(query)-strlen(query)-1);
- }
-
- else if(dbName == FIDO_AUTH) {
+ } else if (dbName == FIDO_AUTH) {
int authIndex = -1;
int mappedIndex = -1;
char *devId = NULL;
snprintf(query, BUFFLEN, "SELECT * FROM AUTHLIST WHERE ");
bool isAnd = false;
- if(authIndex != -1) {
+ if (authIndex != -1) {
snprintf(q, BUFFLEN, "auth_index=%d", authIndex);
strncat(query, q, sizeof(query) - strlen(query)-1);
isAnd = true;
}
- if(mappedIndex != -1) {
- if(isAnd == true) {
+ if (mappedIndex != -1) {
+ if (isAnd == true) {
snprintf(q, BUFFLEN, " AND mapped_index=%d", mappedIndex);
strncat(query, q, sizeof(query) - strlen(query)-1);
- }
- else {
+ } else {
snprintf(q, BUFFLEN, "mapped_index=%d", mappedIndex);
strncat(query, q, sizeof(query)-strlen(query)-1);
isAnd = true;
}
}
- if(devId != NULL) {
- if(isAnd == true) {
+ if (devId != NULL) {
+ if (isAnd == true) {
snprintf(q, BUFFLEN, " AND device_id=\'%s\'", devId);
strncat(query, q, sizeof(query) - strlen(query)-1);
- }
- else {
+ } else {
snprintf(q, BUFFLEN, "device_id=\'%s\'", devId);
strncat(query, q, sizeof(query)-strlen(query)-1);
isAnd = true;
}
}
- if(aaid != NULL) {
- if(isAnd == true) {
+ if (aaid != NULL) {
+ if (isAnd == true) {
snprintf(q, BUFFLEN, " AND aaid=\'%s\'", aaid);
strncat(query, q, sizeof(query) - strlen(query)-1);
- }
- else {
+ } else {
snprintf(q, BUFFLEN, "aaid=\'%s\'", aaid);
strncat(query, q, sizeof(query)-strlen(query)-1);
isAnd = true;
snprintf(q, BUFFLEN, ";");
strncat(query, q, sizeof(query) - strlen(query) - 1);
- }
-
- else if(dbName == FIDO_SECRET) {
+ } else if (dbName == FIDO_SECRET) {
int uid = -1;
char *aaid = NULL;
char *devId = NULL;
parcel->getString(STR_PROP_SECRET1, &secret1);
parcel->getString(STR_PROP_SECRET2, &secret2);
- _INFO("[%d][%s][%s][%s][%s]", uid, aaid, devId, secret1,secret2);
+ _INFO("[%d][%s][%s][%s][%s]", uid, aaid, devId, secret1, secret2);
snprintf(query, BUFFLEN, "SELECT * FROM SECRET WHERE ");
bool isAnd = false;
- if(uid != -1) {
+ if (uid != -1) {
snprintf(q, BUFFLEN, "uid=%d", uid);
strncat(query, q, sizeof(query)-strlen(query)-1);
isAnd = true;
}
- if(aaid != NULL) {
- if(isAnd == true) {
+ if (aaid != NULL) {
+ if (isAnd == true) {
snprintf(q, BUFFLEN, " AND aaid=\'%s\'", aaid);
strncat(query, q, sizeof(query)-strlen(query)-1);
- }
- else {
+ } else {
snprintf(q, BUFFLEN, "aaid=\'%s\'", aaid);
strncat(query, q, sizeof(query)-strlen(query)-1);
isAnd = true;
}
}
- if(devId != NULL) {
- if(isAnd == true) {
+ if (devId != NULL) {
+ if (isAnd == true) {
snprintf(q, BUFFLEN, " AND device_id=\'%s\'", devId);
strncat(query, q, sizeof(query)-strlen(query)-1);
- }
- else {
+ } else {
snprintf(q, BUFFLEN, "device_id=\'%s\'", devId);
strncat(query, q, sizeof(query)-strlen(query)-1);
isAnd = true;
}
}
- if(secret1 != NULL) {
- if(isAnd == true) {
+ if (secret1 != NULL) {
+ if (isAnd == true) {
snprintf(q, BUFFLEN, " AND secret_1=\'%s\'", secret1);
strncat(query, q, sizeof(query)-strlen(query)-1);
- }
- else {
+ } else {
snprintf(q, BUFFLEN, "secret_1=\'%s\'", secret1);
strncat(query, q, sizeof(query)-strlen(query)-1);
isAnd = true;
}
}
- if(secret2 != NULL) {
- if(isAnd == true) {
+ if (secret2 != NULL) {
+ if (isAnd == true) {
snprintf(q, BUFFLEN, " AND secret_2=\'%s\'", secret2);
strncat(query, q, sizeof(query)-strlen(query)-1);
- }
- else {
+ } else {
snprintf(q, BUFFLEN, "secret_2=\'%s\'", secret2);
strncat(query, q, sizeof(query)-strlen(query)-1);
isAnd = true;
sqlite3* dbHandle = openDBHandle(dbName);
RET_IF_FAIL(dbHandle != NULL, SQLITE_ERROR);
- if(dbName == FIDO_ASM) {
+ if (dbName == FIDO_ASM) {
int id = -1;
int authIdx = -1;
snprintf(query, BUFFLEN, "DELETE FROM ASMKEYS WHERE ");
bool isAnd = false;
- if(id != -1) {
+ if (id != -1) {
snprintf(q, BUFFLEN, "id=%d", id);
strncat(query, q, sizeof(query)-strlen(query)-1);
isAnd = true;
}
- if(authIdx != -1) {
- if(isAnd == true) {
+ if (authIdx != -1) {
+ if (isAnd == true) {
snprintf(q, BUFFLEN, " AND auth_idx=%d", authIdx);
strncat(query, q, sizeof(query)-strlen(query)-1);
- }
- else {
+ } else {
snprintf(q, BUFFLEN, "auth_idx=%d", authIdx);
strncat(query, q, sizeof(query)-strlen(query)-1);
isAnd = true;
}
}
- if(callerId != "") {
- if(isAnd == true) {
+ if (callerId != "") {
+ if (isAnd == true) {
snprintf(q, BUFFLEN, " AND caller_id=\'%s\'", callerId.c_str());
strncat(query, q, sizeof(query)-strlen(query)-1);
- }
- else {
+ } else {
snprintf(q, BUFFLEN, "caller_id=\'%s\'", callerId.c_str());
strncat(query, q, sizeof(query)-strlen(query)-1);
isAnd = true;
}
}
- if(appId != "") {
- if(isAnd == true) {
+ if (appId != "") {
+ if (isAnd == true) {
snprintf(q, BUFFLEN, " AND app_id=\'%s\'", appId.c_str());
strncat(query, q, sizeof(query)-strlen(query)-1);
- }
- else {
+ } else {
snprintf(q, BUFFLEN, "app_id=\'%s\'", appId.c_str());
strncat(query, q, sizeof(query)-strlen(query)-1);
isAnd = true;
}
}
- if(keyHandle != "") {
- if(isAnd == true) {
+ if (keyHandle != "") {
+ if (isAnd == true) {
snprintf(q, BUFFLEN, " AND key_handle=\'%s\'", keyHandle.c_str());
strncat(query, q, sizeof(query)-strlen(query)-1);
- }
- else {
+ } else {
snprintf(q, BUFFLEN, "key_handle=\'%s\'", keyHandle.c_str());
strncat(query, q, sizeof(query)-strlen(query)-1);
isAnd = true;
}
}
- if(keyId != "") {
- if(isAnd == true) {
+ if (keyId != "") {
+ if (isAnd == true) {
snprintf(q, BUFFLEN, " AND key_id=\'%s\'", keyId.c_str());
strncat(query, q, sizeof(query)-strlen(query)-1);
- }
- else {
+ } else {
snprintf(q, BUFFLEN, "key_id=\'%s\'", keyId.c_str());
strncat(query, q, sizeof(query)-strlen(query)-1);
isAnd = true;
snprintf(q, BUFFLEN, ";");
strncat(query, q, sizeof(query)-strlen(query)-1);
- }
-
- else if(dbName == FIDO_AUTH) {
+ } else if (dbName == FIDO_AUTH) {
_ERR("AUTHLIST does not allow deletion of entries");
goto CATCH;
}
sqlite3* dbHandle = openDBHandle(dbName);
RET_IF_FAIL(dbHandle != NULL, SQLITE_ERROR);
- if(dbName == FIDO_ASM) {
+ if (dbName == FIDO_ASM) {
snprintf(query, BUFFLEN, "DELETE FROM ASMKEYS;");
- }
-
- else if(dbName == FIDO_AUTH) {
+ } else if (dbName == FIDO_AUTH) {
snprintf(query, BUFFLEN, "DELETE FROM AUTHLIST;");
}
AsmStorage*
AsmStorage::getInstance(void)
{
- if(__this != NULL) {
+ if (__this != NULL) {
return __this;
}
AsmStorage* thisInstance = new AsmStorage();
- if(thisInstance == NULL) {
+ if (thisInstance == NULL) {
return NULL;
}
-
__this = thisInstance;
-
- /*int ret = __this->initDb(FIDO_ASM);
- if(ret == SQLITE_OK) {
- _INFO("Asm database created Successfully / already exists");
- }
-
- ret = __this->initDb(FIDO_AUTH);
- if(ret == SQLITE_OK) {
- _INFO("Auth database created Successfully / already exists");
- }
-
- ret = __this->initDb(FIDO_SECRET);
- if(ret == SQLITE_OK) {
- _INFO("Pin enroll database created Successfully / already exists");
- }*/
return __this;
}
#define RESP_NEG "{\"statusCode\":1}"
-ClientListner::ClientListner(void)
-{
-}
-
-ClientListner::~ClientListner(void)
-{
+ClientListner::ClientListner(void) {}
-}
+ClientListner::~ClientListner(void) {}
ClientListner*
ClientListner::getInstance(void)
_ERR("fd read error(%d)\n", fd);
close(fd);
return -1;
- } else
+ } else {
buf[ret] = 0;
+ }
close(fd);
guint32 upid;
const gchar *sender = NULL;
- sender = g_dbus_method_invocation_get_sender (invocation);
+ sender = g_dbus_method_invocation_get_sender(invocation);
if (!sender) {
_ERR("Failed to get sender");
return "";
}
error = NULL;
- response = g_dbus_connection_call_sync (connection,
+ response = g_dbus_connection_call_sync(connection,
_FREEDESKTOP_SERVICE, _FREEDESKTOP_PATH,
_FREEDESKTOP_INTERFACE, "GetConnectionUnixProcessID",
- g_variant_new ("(s)", sender), ((const GVariantType *) "(u)"),
+ g_variant_new("(s)", sender), ((const GVariantType *) "(u)"),
G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
if (response == NULL) {
_ERR("Failed to get caller id [%s]", error->message);
- g_error_free (error);
+ g_error_free(error);
return "";
}
- g_variant_get (response, "(u)", &upid);
+ g_variant_get(response, "(u)", &upid);
_INFO("Remote msg-bus peer service=%s pid=%u", sender, upid);
remote_pid = (pid_t) upid;
- g_variant_unref (response);
+ g_variant_unref(response);
char *app_id = NULL;
int ret = app_manager_get_app_id(remote_pid, &app_id);
void
ClientListner::onBusAcquired(GDBusConnection *connection, const gchar *name, gpointer user_data)
{
-
_BEGIN;
GDBusInterfaceSkeleton* interface = NULL;
G_CALLBACK(ClientListner::onAuthUiResponse), NULL);
_END;
-
}
void
const gchar *name,
gpointer user_data)
{
-
-
}
void
const gchar *name,
gpointer user_data)
{
- exit (1);
+ exit(1);
}
bool
ClientListner::initDbus(void)
{
-
_BEGIN;
- __ownerId = g_bus_own_name (G_BUS_TYPE_SYSTEM,
+ __ownerId = g_bus_own_name(G_BUS_TYPE_SYSTEM,
ASM_DBUS_NAME,
G_BUS_NAME_OWNER_FLAGS_NONE,
ClientListner::onBusAcquired,
NULL);
- if(__ownerId == 0) {
+ if (__ownerId == 0) {
return false;
}
void
ClientListner::initialize(void)
{
-#if !GLIB_CHECK_VERSION(2,35,0)
+#if !GLIB_CHECK_VERSION(2, 35, 0)
g_type_init();
#endif
#include "AsmAuthRequest.h"
#include "AuthnrTypes.h"
-class AuthenticateState : public IAsmOpState {
+class AuthenticateState:public IAsmOpState {
public:
AuthenticateState(void);
virtual ~AuthenticateState(void);
#include "AsmRegRequest.h"
#include "AuthnrTypes.h"
-class DeregState : public IAsmOpState {
+class DeregState:public IAsmOpState {
public:
DeregState(void);
virtual ~DeregState(void);
#include "IAsmOpState.h"
#include "AsmRegRequest.h"
-class EnrollState : public IAsmOpState {
+class EnrollState:public IAsmOpState {
public:
EnrollState(void);
virtual ~EnrollState(void);
#include "AsmDeregRequest.h"
#include "AuthnrTypes.h"
-class GetRegsState : public IAsmOpState {
+class GetRegsState:public IAsmOpState {
public:
GetRegsState(void);
virtual ~GetRegsState(void);
#include "IAsmOpState.h"
#include "AsmRegRequest.h"
-class InitState : public IAsmOpState {
+class InitState:public IAsmOpState {
public:
InitState(void);
virtual ~InitState(void);
class AsmRequest;
-class RegisterState : public IAsmOpState {
+class RegisterState:public IAsmOpState {
public:
RegisterState(void);
virtual ~RegisterState();
class AsmRequest;
-class TCState : public IAsmOpState {
+class TCState:public IAsmOpState {
public:
TCState(void);
virtual ~TCState();
#include "IAsmOpState.h"
#include "AsmRegRequest.h"
-class VerifyState : public IAsmOpState {
+class VerifyState:public IAsmOpState {
public:
VerifyState(void);
virtual ~VerifyState(void);
#include "TCUiAdaptor.h"
#include "AcUiAdaptor.h"
-AuthenticateState::AuthenticateState(void)
-{
+AuthenticateState::AuthenticateState(void) {}
-}
-
-AuthenticateState::~AuthenticateState()
-{
-
-}
+AuthenticateState::~AuthenticateState() {}
int
AuthenticateState::selectUsernameKeyHandle(AuthenticateReq *signAuthReq, AuthenticateResp *stubResp)
bool isFound = false;
std::vector<std::string>::iterator it = accList.begin();
- for(; it != accList.end(); it++) {
- if(strcmp(uKh->userName, (*it).c_str()) == 0) {
+ for (; it != accList.end(); it++) {
+ if (strcmp(uKh->userName, (*it).c_str()) == 0) {
isFound = true;
break;
}
}
- if(isFound == true) {
+ if (isFound == true) {
ukHmap[uKh->userName] = uKh->kh;
- }
- else {
+ } else {
std::string usrStr(uKh->userName);
accList.push_back(usrStr);
char *userName = uKh->userName;
int uiErr = -1;
//TODO If accList length is 1, then no need of UI, just select the one based on timestamp.
std::string acc = uiAd->confirmAccount(appNameStr, accList, &uiErr);
- if(acc.empty() == true)
+ if (acc.empty() == true)
return -1;
*/
std::map<char*, Buffer*>::iterator it = ukHmap.begin();
keyHandle = NULL;
- for(; it != ukHmap.end(); it++) {
- if(strcmp(it->first, acc.c_str()) == 0)
+ for (; it != ukHmap.end(); it++) {
+ if (strcmp(it->first, acc.c_str()) == 0)
keyHandle = it->second;
}
signAuthReq->khHList = NULL;
}
if (isBound == false) {
-
_INFO("To Roaming Authenticator");
if (asmSignReq->getKeyIds().size() > 0) {
std::vector<std::string> kIdList = asmSignReq->getKeyIds();
signAuthReq->khHList = g_list_append(signAuthReq->khHList, strdup(kIdStr.c_str()));
}
}
- }
- else {
-
+ } else {
_INFO("To Bound Authenticator");
std::vector<std::string> kIdList = asmSignReq->getKeyIds();
- if(!kIdList.empty()) {
-
+ if (!kIdList.empty()) {
std::vector<std::string>::iterator kIdIter = kIdList.begin();
for (; kIdIter != kIdList.end(); ++kIdIter) {
-
std::string kIdStr = *kIdIter;
_INFO("AuthenticateState::createStubRequestSign:: key id = [%s]", kIdStr.c_str());
std::vector<IStorageParcel*> *searchRes = AsmStorage::getInstance()->searchData(searchParcel);
if (searchRes != NULL) {
-
_INFO("AuthenticateState::createStubRequestSign:: Records found in database corresponding to keyId = [%d]", searchRes->size());
std::vector<IStorageParcel*>::iterator searchResIter = searchRes->begin();
for (; searchResIter != searchRes->end(); ++searchResIter) {
-
_INFO("AuthenticateState::createStubRequestSign:: inside searchRes loop");
IStorageParcel *parcel = *searchResIter;
char *kh = NULL;
int res = parcel->getString(STR_PROP_KEY_HANDLE, &kh);
- if (res == 0)
- {
+ if (res == 0) {
_INFO("AuthenticateState::createStubRequestSign:: Length of b64 encoded keyHandle : [%d]", strlen(kh));
signAuthReq->khHList = g_list_append(signAuthReq->khHList, kh);
- }
- else
+ } else {
_INFO("AuthenticateState::createStubRequestSign:: AsmStorageParcel::getString FAIL");
+ }
}
signAuthReq->khHList = g_list_first(signAuthReq->khHList);
}
}
- }
- else {
+ } else {
_INFO("AuthenticateState::createStubRequestSign:: KeyId empty");
IStorageParcel *searchParcel = new AsmStorageParcel();
std::vector<IStorageParcel*> *searchRes = AsmStorage::getInstance()->searchData(searchParcel);
if (searchRes != NULL) {
-
_INFO("AuthenticateState::createStubRequestSign::Records found in database corresponding to appId = [%d]", searchRes->size());
std::vector<IStorageParcel*>::iterator searchResIter = searchRes->begin();
for (; searchResIter != searchRes->end(); ++searchResIter) {
-
IStorageParcel *parcel = *searchResIter;
char *kh = NULL;
int res = parcel->getString(STR_PROP_KEY_HANDLE, &kh);
/*Coming from Roaming Agent Service*/
/*Only Bound Auth allowed*/
- if(asmReq->getCustomRequest() != NULL) {
+ if (asmReq->getCustomRequest() != NULL) {
AuthenticateReq *signAuthReq = (AuthenticateReq*)asmReq->getCustomRequest();
RET_IF_FAIL(signAuthReq != NULL, -1);
std::vector<IStorageParcel*> *searchRes = AsmStorage::getInstance()->searchData(searchParcel);
if (searchRes != NULL) {
-
int recFound = searchRes->size();
_INFO("Records found in database corresponding to appId = [%d]", recFound);
if (recFound <= 0) {
std::vector<IStorageParcel*>::iterator searchResIter = searchRes->begin();
for (; searchResIter != searchRes->end(); ++searchResIter) {
-
IStorageParcel *parcel = *searchResIter;
char *kh = NULL;
int res = parcel->getString(STR_PROP_KEY_HANDLE, &kh);
GList *recvdKhListIter = g_list_first(signAuthReq->khHList);
while (recvdKhListIter != NULL) {
-
char *recvKh = (char*)(recvdKhListIter->data);
unsigned char *recvKhDec = AsmCrypto::ToBase64Url((unsigned char*)recvKh, strlen(recvKh));
if (recvKhDec != NULL) {
-
std::string kIdStr((char*)recvKhDec);
SAFE_DELETE(recvKhDec);
searchParcel->setString(STR_PROP_KEY_ID, kIdStr);
std::vector<IStorageParcel*> *searchRes = AsmStorage::getInstance()->searchData(searchParcel);
if (searchRes != NULL) {
-
int recFound = searchRes->size();
_INFO("Records found in database corresponding to appId = [%d]", recFound);
if (recFound <= 0) {
std::vector<IStorageParcel*>::iterator searchResIter = searchRes->begin();
for (; searchResIter != searchRes->end(); ++searchResIter) {
-
IStorageParcel *parcel = *searchResIter;
char *kh = NULL;
int res = parcel->getString(STR_PROP_KEY_HANDLE, &kh);
GList *recvdKhListIter = g_list_first(signAuthReq->khHList);
while (recvdKhListIter != NULL) {
-
char *recvKh = (char*)(recvdKhListIter->data);
/*unsigned char *recvKhDec = AsmCrypto::ToBase64Url((unsigned char*)recvKh, strlen(recvKh));*/
if (recvKh != NULL) {
-
std::string kIdStr((char*)recvKh);
searchParcel->setString(STR_PROP_KEY_ID, kIdStr);
_INFO("search=[%s][%s]", appIdStr.c_str(), kIdStr.c_str());
std::vector<IStorageParcel*> *searchRes = AsmStorage::getInstance()->searchData(searchParcel);
if (searchRes != NULL) {
-
int recFound = searchRes->size();
_INFO("Records found in database corresponding to appId = [%d]", recFound);
if (recFound <= 0) {
std::vector<IStorageParcel*>::iterator searchResIter = searchRes->begin();
for (; searchResIter != searchRes->end(); ++searchResIter) {
-
IStorageParcel *parcel = *searchResIter;
char *kh = NULL;
int res = parcel->getString(STR_PROP_KEY_HANDLE, &kh);
storedKhList = g_list_first(storedKhList);
signAuthReq->khHList = storedKhList;
_INFO("Matched khlist count =[%d]", g_list_length(signAuthReq->khHList));
-
}
}
AuthenticateResp *stubResp = stub->processAuthenticate(signAuthReq);
RET_IF_FAIL(stubResp != NULL, -1);
- if(stubResp->uKhList != NULL) {
+ if (stubResp->uKhList != NULL) {
int ret = selectUsernameKeyHandle(signAuthReq, stubResp);
RET_IF_FAIL(ret == 0, -1);
if (tlvRespB64 != NULL) {
*out = tlvRespB64;
}
- }
- else
- {
+ } else {
/*Coming from FIDO Client Service*/
AuthenticateReq *signAuthReq = createStubRequestSign(asmReq, str);
if ((signAuthReq->khHList == NULL) ||
(g_list_length(signAuthReq->khHList) <= 0)) {
-
if (stub->getType() != AUTH_TYPE_ROAMING) {
_ERR("No keys registered");
RET_IF_FAIL(stubResp != NULL, -1);
/* ASM UI call when username-keyHandle list is not NULL*/
- if(stub->getType() == AUTH_TYPE_BOUND) {
- if(stubResp->uKhList != NULL) {
+ if (stub->getType() == AUTH_TYPE_BOUND) {
+ if (stubResp->uKhList != NULL) {
int ret = selectUsernameKeyHandle(signAuthReq, stubResp);
RET_IF_FAIL(ret == 0, -1);
}
#include <stdlib.h>
-DeregState::DeregState(void)
-{
-
-}
-
-DeregState::~DeregState(void)
-{
+DeregState::DeregState(void) {}
-}
+DeregState::~DeregState(void) {}
int
DeregState::deleteAsmRecord(char *appId, char *keyId)
int setAppId = parcel->setString(STR_PROP_APP_ID, appId);
int setKeyId = parcel->setString(STR_PROP_KEY_ID, keyId);
- if(setAppId == 0 && setKeyId == 0) {
+ if (setAppId == 0 && setKeyId == 0) {
int ret = AsmStorage::getInstance()->deleteData(parcel);
- if(ret == SQLITE_ERROR) {
+ if (ret == SQLITE_ERROR) {
_INFO("Record Deleted :: FAIL");
return -1;
}
deRegAuthReq->keyId = _SAFE_DUP(asmDeRegReq->getKeyId().c_str());
/*KHAccessToken = Hash(AppId, FIDO Client ID, PersonaId, AsmToken)*/
- deRegAuthReq->khATok = authStub->hash(AsmCrypto::getKHAccessToken(asmDeRegReq->getAppId(),isBound));
+ deRegAuthReq->khATok = authStub->hash(AsmCrypto::getKHAccessToken(asmDeRegReq->getAppId(), isBound));
return deRegAuthReq;
}
/*Coming from Roaming Agent Service*/
/*Only Bound Auth allowed*/
- if(asmReq->getCustomRequest() != NULL) {
-
+ if (asmReq->getCustomRequest() != NULL) {
_INFO("");
DeregReq *deRegAuthReq = (DeregReq*)asmReq->getCustomRequest();
if (deRegAuthReq->keyId == NULL) {
_INFO("About to delete=[%s][%s]", deRegAuthReq->appId, (char*)keyIdEnc);
int deleteRecord = deleteAsmRecord(deRegAuthReq->appId, (char*)keyIdEnc);
- if(deleteRecord == -1)
+ if (deleteRecord == -1)
return -1;
/*Temp fix: try to delete b64enc keyid too*/
if (tlvRespB64 != NULL) {
*out = tlvRespB64;
}
- }
- else {
-
+ } else {
_INFO("");
/*Coming from FIDO Client Service*/
}
}
- if(authStub->getType() == AUTH_TYPE_BOUND) {
- if(isBound == true) {
-
+ if (authStub->getType() == AUTH_TYPE_BOUND) {
+ if (isBound == true) {
_INFO("");
std::string appIdStr = asmDeRegReq->getAppId();
std::string keyIdStr = asmDeRegReq->getKeyId();
char *appId = strdup(appIdStr.c_str());
char *keyId = strdup(keyIdStr.c_str());
int deleteRecord = deleteAsmRecord(appId, keyId);
- if(deleteRecord == -1)
+ if (deleteRecord == -1)
return -1;
}
}
#define uid 5001
-EnrollState::EnrollState(void)
-{
+EnrollState::EnrollState(void) {}
-}
-
-EnrollState::~EnrollState()
-{
-
-}
+EnrollState::~EnrollState() {}
char *
EnrollState::composeEnrollRequest(const char *appId, const char *aaid)
AsmRegRequest *asmRegReq = (AsmRegRequest*)asmReq->getArgs();
appId = asmRegReq->getAppId();
}
- } else if(strcmp(reqType.c_str(), STRING_OP_TYPE_AUTH) == 0) {
+ } else if (strcmp(reqType.c_str(), STRING_OP_TYPE_AUTH) == 0) {
if (asmReq->getCustomRequest() != NULL) {
_INFO("Custom req auth");
AuthenticateReq *authAuthReq = (AuthenticateReq*)(asmReq->getCustomRequest());
_INFO("Custom req after getInfo");
if (getAuthInfoResp->authList != NULL) {
-
_INFO("Iter authlist");
GList *authListIter = g_list_first(getAuthInfoResp->authList);
while(authListIter != NULL) {
_INFO("enroll json composed success");
return stub->enroll(enrollJson);
- }
- else {
+ } else {
_INFO("EnrollState::handle:: User already enrolled");
if(resultList->size() > 1) {
_INFO("EnrollState::handle:: More than one records obtained from Secret Database");
#include <stdlib.h>
-GetRegsState::GetRegsState(void)
-{
-
-}
-
-GetRegsState::~GetRegsState(void)
-{
+GetRegsState::GetRegsState(void) {}
-}
+GetRegsState::~GetRegsState(void) {}
int
int res = parcel->getString(STR_PROP_APP_ID, &appId);
int res1 = parcel->getString(STR_PROP_KEY_ID, &kId);
- if ((res == 0) &&
- (res1 == 0)) {
-
+ if ((res == 0) && (res1 == 0)) {
std::string appIdStr((const char *)appId, strlen(appId));
std::string kIdStr((const char *)kId, strlen(kId));
keyIdList = it->second;
keyIdList.push_back(kIdStr);
it->second = keyIdList;
- }
- else {
+ } else {
keyIdList.push_back(kIdStr);
regMap.insert(std::pair<std::string, std::vector<std::string> >(appIdStr, keyIdList));
}
#include <stdlib.h>
-RegisterState::RegisterState(void)
-{
-
-}
-
-RegisterState::~RegisterState()
-{
+RegisterState::RegisterState(void) {}
-}
+RegisterState::~RegisterState() {}
RegisterReq*
RegisterState::createStubRequestRegister(AsmRequest *asmReq, const char *vTok)
/*Coming from Roaming Agent Service*/
/*Only Bound Auth allowed*/
if (asmReq->getCustomRequest() != NULL) {
-
/*Since this is TLV request, so this is expected to have proper AuthIndex*/
RegisterReq *regAuthReq = (RegisterReq*)(asmReq->getCustomRequest());
RegisterResp *stubResp = stub->processRegister(regAuthReq);
_INFO("");
AuthenticatorInfo *authInfo = (AuthenticatorInfo*)(authListIter->data);
if (authInfo->__isRoamingAuthenticator == false) {
-
IStorageParcel *regParcel = new AsmStorageParcel();
regParcel->setInt(INT_PROP_AUTH_IDX, authInfo->__authenticatorIndex);
#include "AsmAuthRequest.h"
#include "AuthnrTypes.h"
-TCState::TCState(void)
-{
-
-}
-
-TCState::~TCState()
-{
+TCState::TCState(void) {}
-}
+TCState::~TCState() {}
#define ASM_UI_SUPPORTED_TYPE "text/plain"
*appId = appIdReal;
return 0;
-
}
if (asmReq->getCustomRequest() != NULL) {
-
AuthenticateReq *authAuthReq = (AuthenticateReq*)(asmReq->getCustomRequest());
RET_IF_FAIL(authAuthReq != NULL, -1);
/*TODO get Uid of owner*/
#define uid 5001
-VerifyState::VerifyState(void)
-{
-
-}
+VerifyState::VerifyState(void) {}
-VerifyState::~VerifyState()
-{
-
-}
+VerifyState::~VerifyState() {}
int
VerifyState::handle(IAuthStub *stub, AsmRequest *asmReq, const char *str, char **out)
char *fch = NULL;
if (asmReq->getCustomRequest() == NULL) {
- if(strcmp(reqType.c_str(), STRING_OP_TYPE_REG) == 0) {
+ if (strcmp(reqType.c_str(), STRING_OP_TYPE_REG) == 0) {
AsmRegRequest *asmRegReq = (AsmRegRequest*)asmReq->getArgs();
if (asmRegReq == NULL) {
_ERR("");
snprintf(cmd, 128 - 1, "%s", "registration");
- } else if(strcmp(reqType.c_str(), STRING_OP_TYPE_AUTH) == 0) {
-
+ } else if (strcmp(reqType.c_str(), STRING_OP_TYPE_AUTH) == 0) {
AsmAuthRequest *asmAuthReq = (AsmAuthRequest*)asmReq->getArgs();
if (asmAuthReq == NULL) {
_ERR("");
} else {
_INFO("");
- if(strcmp(reqType.c_str(), STRING_OP_TYPE_REG) == 0) {
+ if (strcmp(reqType.c_str(), STRING_OP_TYPE_REG) == 0) {
RegisterReq *regAuthReq = (RegisterReq*)(asmReq->getCustomRequest());
if (regAuthReq == NULL) {
_ERR("");
cmd = (char*)calloc(128, sizeof(char));
snprintf(cmd, 128 - 1, "%s", "registration");
- } else if(strcmp(reqType.c_str(), STRING_OP_TYPE_AUTH) == 0) {
-
+ } else if (strcmp(reqType.c_str(), STRING_OP_TYPE_AUTH) == 0) {
AuthenticateReq *signAuthReq = (AuthenticateReq*)(asmReq->getCustomRequest());
if (signAuthReq == NULL) {
_ERR("");
cmd = (char*)calloc(128, sizeof(char));
snprintf(cmd, 128 - 1, "%s", "authentication");
}
-
}
_INFO("");
return stub->verify(cmd, fch, out);
int mappedIndex = asmReq->getAuthIndex();
- if(strcmp(reqType.c_str(), STRING_OP_TYPE_REG) == 0) {
+ if (strcmp(reqType.c_str(), STRING_OP_TYPE_REG) == 0) {
if (asmReq->getCustomRequest() != NULL) {
_INFO("Custom req reg");
RegisterReq *regAuthReq = (RegisterReq*)(asmReq->getCustomRequest());
AsmRegRequest *asmRegReq = (AsmRegRequest*)asmReq->getArgs();
appId = asmRegReq->getAppId();
}
- } else if(strcmp(reqType.c_str(), STRING_OP_TYPE_AUTH) == 0) {
+ } else if (strcmp(reqType.c_str(), STRING_OP_TYPE_AUTH) == 0) {
_INFO("Request Type is Authenticate");
if (asmReq->getCustomRequest() != NULL) {
_INFO("Custom auth reg");
GetAuthInfoResp *getAuthInfoResp = stub->getInfo();
if (getAuthInfoResp->authList != NULL) {
-
GList *authListIter = g_list_first(getAuthInfoResp->authList);
while(authListIter != NULL) {
AuthenticatorInfo *authInfo = (AuthenticatorInfo*)(authListIter->data);
- if(authInfo->__authenticatorIndex == mappedIndex) {
+ if (authInfo->__authenticatorIndex == mappedIndex) {
aaid = authInfo->__aaid;
break;
}
/*TODO: Verif token searching on DB must be done via Auth plugin*/
IStorageParcel *parcel = new SecretStorageParcel();
int res = parcel->setString(STR_PROP_AAID, aaid);
- if(res != 0)
+ if (res != 0)
return -1;
res = parcel->setString(STR_PROP_DEV_ID, AsmCrypto::getDeviceId());
- if(res != 0)
+ if (res != 0)
return -1;
res = parcel->setInt(INT_PROP_UID, uid);
- if(res != 0)
+ if (res != 0)
return -1;
std::vector<IStorageParcel*> *resultList = AsmStorage::getInstance()->searchData(parcel);
if ((resultList == NULL) || (resultList->size() == 0)) {
_ERR("VerifyState::handle:: User not registerd");
return -1;
- }
- else {
+ } else {
_INFO("VerifyState::handle:: User is registerd");
- if(resultList->size() > 1) {
+ if (resultList->size() > 1) {
_INFO("VerifyState::handle:: More than one records obtained from Secret Database");
return -1;
}
*out = vToken;
}
- }
- else {
+ } else {
return -1;
}
JsonNode *root_node = NULL;
*generator = json_generator_new();
- if(*generator == NULL) {
+ if (*generator == NULL) {
_INFO("json_generator_new is NULL");
goto CATCH;
}
}
*root_obj = json_object_new();
- if(*root_obj == NULL) {
+ if (*root_obj == NULL) {
_INFO("json_object_new is NULL");
goto CATCH;
}
strncpy(sub_str, str + i, chunk_size);
_INFO("log : [%s]", sub_str);
}
-
}
static char *
json = json_generator_to_data(generator, &len);
if (json != NULL) {
_INFO("%s", json);
-
}
return json;
int ret = encodableDeReg.setEncoder(EID_UAFV1_DEREG_RESP);
if (ret == 0) {
_INFO("setEncoder EID_UAFV1_DEREG_RESP PASS \n");
- }
- else {
+ } else {
_INFO("setEncoder EID_UAFV1_DEREG_RESP FAIL \n");
return NULL;
}
getDeRegRespInfoBuff = encodableDeReg.encode();
if (getDeRegRespInfoBuff != NULL) {
_INFO("encode EID_UAFV1_DEREG_RESP PASS \n");
- }
- else {
+ } else {
_INFO("encode EID_UAFV1_DEREG_RESP FAIL \n");
return NULL;
}
int ret = encodableAuthReq.setEncoder(EID_UAFV1_SIGN_REQ);
if (ret == 0) {
_INFO("setEncoder EID_UAFV1_SIGN_REQ PASS \n");
- }
- else {
+ } else {
_INFO("setEncoder EID_UAFV1_SIGN_REQ FAIL \n");
SAFE_DELETE(getAuthRespInfo);
return NULL;
getAuthReqInfo = encodableAuthReq.decode(assert_req);
if (getAuthReqInfo != NULL) {
_INFO("decode EID_UAFV1_SIGN_REQ PASS \n");
- }
- else {
+ } else {
_INFO("decode EID_UAFV1_SIGN_REQ FAIL \n");
SAFE_DELETE(getAuthRespInfo);
return NULL;
int khHListSize = g_list_length(getAuthReqInfo->khHList);
- if(khHListSize > 1) {
-
+ if (khHListSize > 1) {
_INFO("Keyhandle size > 1 = [%d]", khHListSize);
/*Copy {Command.KeyHandle, RawKeyHandle.username}*/
}
} else {
-
_INFO("processAuthenticate:: Keyhandle size = 1.");
/*Set Authentication Mode*/
int authMode = 0x01;
getAuthRespInfo->authAssertion->sigData->tcHash = ALLOC(Buffer);
/*tcHash when authMode = 0x02 i.e transaction content is not empty*/
- if(getAuthReqInfo->tc != NULL) {
+ if (getAuthReqInfo->tc != NULL) {
unsigned char tcHash[32];
getAuthRespInfo->authAssertion->sigData->assrtInfo->authMode = 0x02;
int ret = AsmCrypto::genHash256(getAuthReqInfo->tc, strlen(getAuthReqInfo->tc), tcHash);
- if(ret == false) {
+ if (ret == false) {
_ERR("processAuthenticate:: Failed to create Transaction content hash.");
SAFE_DELETE(getAuthRespInfo);
SAFE_DELETE(keyId_b64_enc);
getAuthRespInfo->authAssertion->sigData->tcHash->len = DIGEST_LEN;
getAuthRespInfo->authAssertion->sigData->tcHash->data = NALLOC(DIGEST_LEN, uint8_t);
memcpy(getAuthRespInfo->authAssertion->sigData->tcHash->data, tcHash, DIGEST_LEN);
- }
- /*authMode = 0x01*/
- else {
+ } else { /*authMode = 0x01*/
getAuthRespInfo->authAssertion->sigData->tcHash->len = 0;
}
int ret = encodableSigData.setEncoder(EID_UAFV1_SIGN_DATA_RESP);
if (ret == 0) {
_INFO("setEncoder EID_UAFV1_SIGN_DATA_RESP PASS");
- }
- else {
+ } else {
_INFO("setEncoder EID_UAFV1_SIGN_DATA_RESP FAIL");
SAFE_DELETE(getAuthRespInfo);
return NULL;
getSigDataInfoBuff = encodableSigData.encode();
if (getSigDataInfoBuff != NULL) {
_INFO("encode EID_UAFV1_SIGN_DATA_RESP PASS");
- }
- else {
+ } else {
_INFO("encode EID_UAFV1_SIGN_DATA_RESP FAIL");
SAFE_DELETE(getAuthRespInfo);
return NULL;
_ERR("processAuthenticate:: Failed to Get Sign Response");
SAFE_DELETE(getAuthRespInfo);
return NULL;
-
}
if (getAuthReqInfo->khHList != NULL)
ret = encodableAuthResp.setEncoder(EID_UAFV1_SIGN_RESP);
if (ret == 0) {
_INFO("setEncoder EID_UAFV1_SIGN_RESP PASS \n");
- }
- else {
+ } else {
_INFO("setEncoder EID_UAFV1_SIGN_RESP FAIL \n");
SAFE_DELETE(getAuthRespInfo);
return NULL;
getAuthRespInfoBuff = encodableAuthResp.encode();
if (getAuthRespInfoBuff != NULL) {
_INFO("encode EID_UAFV1_SIGN_RESP PASS \n");
- }
- else {
+ } else {
_INFO("encode EID_UAFV1_SIGN_RESP FAIL \n");
SAFE_DELETE(getAuthRespInfo);
return NULL;
void *
processRegister(unsigned char *assert_req)
{
-
_INFO("========ProcessRegister start=========");
OpenSSL_add_all_algorithms();
int ret = encodableRegReq.setEncoder(EID_UAFV1_REGISTER_REQ);
if (ret == 0) {
_INFO("setEncoder EID_UAFV1_REGISTER_REQ PASS \n");
- }
- else {
+ } else {
_INFO("setEncoder EID_UAFV1_REGISTER_REQ FAIL \n");
SAFE_DELETE(getRegRespInfo);
return NULL;
getRegReqInfo = encodableRegReq.decode(assert_req);
if (getRegReqInfo != NULL) {
_INFO("decode EID_UAFV1_REGISTER_REQ PASS \n");
- }
- else {
+ } else {
_INFO("decode EID_UAFV1_REGISTER_REQ FAIL \n");
SAFE_DELETE(getRegRespInfo);
return NULL;
ret = encodableKrd.setEncoder(EID_UAFV1_REG_ASSERTION_KRD_RESP);
if (ret == 0) {
_INFO("setEncoder EID_UAFV1_REG_ASSERTION_KRD_RESP PASS");
- }
- else {
+ } else {
_INFO("setEncoder EID_UAFV1_REG_ASSERTION_KRD_RESP FAIL");
}
uafv1KrdBuff = encodableKrd.encode();
if (uafv1KrdBuff != NULL) {
_INFO("encode EID_UAFV1_REG_ASSERTION_KRD_RESP PASS, length of encoded UAFV1KRD is = [%d]", uafv1KrdBuff->len);
- }
- else {
+ } else {
_ERR("encode EID_UAFV1_REG_ASSERTION_KRD_RESP FAIL");
SAFE_DELETE(getRegRespInfo);
return NULL;
ret = encodableRegResp.setEncoder(EID_UAFV1_REGISTER_RESP);
if (ret == 0) {
_INFO("setEncoder EID_UAFV1_REGISTER_RESP PASS \n");
- }
- else {
+ } else {
_INFO("setEncoder EID_UAFV1_REGISTER_RESP FAIL \n");
SAFE_DELETE(krdStr);
SAFE_DELETE(getRegRespInfo->kh);
getRegRespInfoBuff = encodableRegResp.encode();
if (getRegRespInfoBuff != NULL) {
_INFO("decode EID_UAFV1_REGISTER_RESP PASS \n");
- }
- else {
+ } else {
_INFO("decode EID_UAFV1_REGISTER_RESP FAIL \n");
SAFE_DELETE(krdStr);
SAFE_DELETE(getRegRespInfo);
int ret = encodableResp.setEncoder(EID_UAFV1_GETINFO_RESP);
if (ret == 0) {
_INFO("setEncoder EID_UAFV1_GETINFO_RESP PASS \n");
- }
- else {
+ } else {
_INFO("setEncoder EID_UAFV1_GETINFO_RESP FAIL \n");
SAFE_DELETE(authInfo->__aaid);
SAFE_DELETE(authInfo->__meta);
getInfoRespBuff = encodableResp.encode();
if (getInfoRespBuff != 0) {
_INFO("encode EID_UAFV1_GETINFO_RESP PASS \n");
- }
- else {
+ } else {
_INFO("encode EID_UAFV1_GETINFO_RESP FAIL \n");
SAFE_DELETE(authInfo->__aaid);
SAFE_DELETE(authInfo->__meta);
bool foundMember = false;
switch(root->tag) {
-
case TAG_UAFV1_GETINFO_CMD:
getRespBuff = (Buffer*)processGetInfo();
- if(getRespBuff != NULL)
+ if (getRespBuff != NULL)
*assrt_resp = getRespBuff->data;
foundMember = true;
break;
case TAG_UAFV1_REGISTER_CMD:
getRespBuff = (Buffer*)processRegister(assert_req);
- if(getRespBuff != NULL)
+ if (getRespBuff != NULL)
*assrt_resp = getRespBuff->data;
foundMember = true;
break;
case TAG_UAFV1_SIGN_CMD:
getRespBuff = (Buffer*)processAuthenticate(assert_req);
- if(getRespBuff != NULL)
+ if (getRespBuff != NULL)
*assrt_resp = getRespBuff->data;
foundMember = true;
break;
case TAG_UAFV1_DEREGISTER_CMD:
getRespBuff = (Buffer*)processDeRegister(assert_req);
- if(getRespBuff != NULL)
+ if (getRespBuff != NULL)
*assrt_resp = getRespBuff->data;
foundMember = true;
break;
SAFE_DELETE(root->val);
SAFE_DELETE(root);
- if(foundMember == false)
+ if (foundMember == false)
return -1;
_INFO("fido_auth_plugin_fido_command_process:: end");
char *val_ts_str = NULL;
buxton_value_get_string(val_ts, (const char **)&val_ts_str);
if (val_ts_str != NULL) {
- /*poll_count++;*/
- /*if ((poll_count % 50) == 0)
- _INFO("[%s][%s]", val_ts_str, ts_str);*/
-
if (strcmp(val_ts_str, ts_str) == 0) {
_INFO("Received matching ts");
buxton_value *val_bool = NULL;
if (val_verifiy != 0) {
buxton_free_layer(layer);
return 0;
- }
- else {
+ } else {
buxton_free_layer(layer);
return -1;
}
{
return ATTACHMENT_HINT_INTERNAL;
}
-
}
-
-/*int fido_auth_plugin_hash(const char *ip, char **op);
-int fido_auth_plugin_confirm_account(GList *acc_list, char **selected_acc);
-int fido_auth_plugin_confirm_tc(const transaction_s *tr);*/
#define UTIL_H_
#define RET_IF_FAIL_VOID(cond) do {\
- if (!(cond)){\
+ if (!(cond)) {\
return;\
- }\
-} while(0)
+ } \
+} while (0)
#define RET_IF_FAIL(cond, err) do {\
- if (!(cond)){\
+ if (!(cond)) {\
return err;\
- }\
-} while(0)
+ } \
+} while (0)
#define CATCH_IF_FAIL(cond) do {\
- if (!(cond)){\
+ if (!(cond)) {\
goto CATCH;\
- }\
-} while(0)
+ } \
+} while (0)
#define CATCH_IF_FAIL_X(cond, expr) do {\
- if (!(cond)){\
+ if (!(cond)) {\
expr;\
goto CATCH;\
- }\
-} while(0)
+ } \
+} while (0)
#define GOTO_IF_FAIL(cond, catch_block) do {\
- if (!(cond)){\
+ if (!(cond)) {\
goto catch_block;\
- }\
-} while(0)
+ } \
+} while (0)
#define SAFE_DELETE(x) do {\
if (x != NULL) {\
free(x); \
x = NULL;\
- }\
-} while(0)
+ } \
+} while (0)
#define _SAFE_DUP(x) ((x) ? strdup(x) : NULL)
memcpy(base64, in, inlen);
int i;
- for (i = 0; i < inlen; i++) {
+ for (i = 0; i < inlen; i++) {
if (base64[i] == '-')
base64[i] = '+';
-
else if (base64[i] == '_')
base64[i] = '/';
-
#include "fido_asm_shell_tc_util.h"
-
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include "JsonUtil.h"
#include "AsmOp.h"
#include "AsmOpFactory.h"
-
#include <openssl/bio.h>
#include <openssl/evp.h>
#include <openssl/buffer.h>
free(x); \
x = NULL;\
}\
-} while(0)
+} while (0)
/* A 256 bit key */
const unsigned char *key_test = (unsigned char *)"01234567890123456789012345678901";
b64UrlDecode(const unsigned char *in, int inlen,
unsigned char *out, int *outlen)
{
-
int npadChars = (inlen %4) == 0 ? 0 : (4 - (inlen%4));
unsigned char *base64 = (unsigned char *) malloc(inlen + npadChars);
- if(base64 == NULL) {
+ if (base64 == NULL) {
return -1;
}
memcpy(base64, in, inlen);
int i;
- for(i =0; i < inlen ; i++) {
- if(base64[i] == '-')
+ for (i =0; i < inlen ; i++) {
+ if (base64[i] == '-')
base64[i] = '+';
- else if(base64[i] == '_')
+ else if (base64[i] == '_')
base64[i] = '/';
-
}
- if(npadChars != 0)
+ if (npadChars != 0)
memset(base64 + inlen, '=', npadChars);
BIO * b64 = NULL;
BIO * bmem = NULL;
b64 = BIO_new(BIO_f_base64());
- if(b64 == NULL) {
-
+ if (b64 == NULL) {
SAFE_DELETE(base64);
return -1;
}
BIO_set_flags(b64, BIO_FLAGS_BASE64_NO_NL);
bmem = BIO_new_mem_buf(base64, inlen);
- if(bmem == NULL) {
-
+ if (bmem == NULL) {
SAFE_DELETE(base64);
return -1;
}
bmem = BIO_push(b64, bmem);
*outlen = BIO_read(bmem, out, inlen);
- if(*outlen <= 0) {
-
+ if (*outlen <= 0) {
SAFE_DELETE(base64);
return -1;
}
- if(bmem)
+ if (bmem)
BIO_free_all(bmem);
return 0;
void
testTLV_getInfo(void)
{
-
//int i = 0;
printf("==============testTLV GETINFO start============== \n");
auth->__meta->transactionConfirmationDisplay = 0x0000;
auth->__meta->authenticationAlg = 0x0001;
- auth->__tcDispConType = (char*)calloc(1,128);
+ auth->__tcDispConType = (char*)calloc(1, 128);
snprintf(auth->__tcDispConType, 127, "%s", "text/plain");
auth->__tcDisplayPNGCharacteristics = g_list_first(tcDispList);
- auth->__assertionScheme = (char*)calloc(1,128);
+ auth->__assertionScheme = (char*)calloc(1, 128);
snprintf(auth->__assertionScheme, 127, "%s", "UAFVITLV");
GList *attTypes = NULL;
int ret = encodableResp.setEncoder(EID_UAFV1_GETINFO_RESP);
if (ret == 0) {
printf("setEncoder EID_UAFV1_GETINFO_RESP PASS \n");
- }
- else {
+ } else {
printf("setEncoder EID_UAFV1_GETINFO_RESP FAIL \n");
goto ERR;
}
if (getInfoRespBuff != 0) {
printf("encode EID_UAFV1_GETINFO_RESP PASS \n");
print_hex(getInfoRespBuff);
- }
- else {
+ } else {
printf("encode EID_UAFV1_GETINFO_RESP FAIL \n");
goto ERR;
}
getInfoResp = encodableResp.decode(getInfoRespBuff->data);
if (getInfoResp != NULL) {
printf("decode GetAuthInfoResp value PASS \n");
- }
- else {
+ } else {
printf("decode GetAuthInfoResp value FAIL \n");
goto ERR;
}
authinfoList = getInfoResp->authList;
if (authinfoList != NULL) {
printf("Non NULL authinfoList value PASS \n");
- }
- else {
+ } else {
printf("Non NULL authinfoList value FAIL \n");
goto ERR;
}
authInfo = (AuthenticatorInfo*)(g_list_first(authinfoList)->data);
if (authInfo != NULL) {
printf("Non NULL authInfo value PASS \n");
- }
- else {
+ } else {
printf("Non NULL authInfo value FAIL \n");
goto ERR;
}
if (strcmp(authInfo->__aaid, auth->__aaid) == 0) {
printf("AAID PASS \n");
- }
- else {
+ } else {
printf("AAID FAIL \n");
goto ERR;
}
if (authInfo->__authenticatorIndex == auth->__authenticatorIndex) {
printf("Authenticator Index PASS \n");
- }
- else {
+ } else {
printf("Authenticator Index FAIL \n");
goto ERR;
}
//=========================================Meta Data========================================//
if (authInfo->__meta != NULL) {
printf("Authenticator Metadata NOT NULL PASS \n");
- }
- else {
+ } else {
printf("Authenticator Metadata NOT NULL FAIL \n");
goto ERR;
}
if (authInfo->__meta->authenticatorType == auth->__meta->authenticatorType) {
printf("Authenticator Metadata authenticatorType PASS \n");
- }
- else {
+ } else {
printf("Authenticator Metadata authenticatorType FAIL \n");
//goto ERR;
}
if (authInfo->__meta->authenticationAlg == auth->__meta->authenticationAlg) {
printf("Authenticator Metadata authenticationAlg PASS \n");
- }
- else {
+ } else {
printf("Authenticator Metadata authenticationAlg FAIL \n");
//goto ERR;
}
if (authInfo->__meta->keyProtection == auth->__meta->keyProtection) {
printf("Authenticator Metadata keyProtection PASS \n");
- }
- else {
+ } else {
printf("Authenticator Metadata keyProtection FAIL \n");
//goto ERR;
}
if (authInfo->__meta->matcherProtection == auth->__meta->matcherProtection) {
printf("Authenticator Metadata matcherProtection PASS \n");
- }
- else {
+ } else {
printf("Authenticator Metadata matcherProtection FAIL \n");
//goto ERR;
}
if (authInfo->__meta->maxKeyHandles == auth->__meta->maxKeyHandles) {
printf("Authenticator Metadata maxKeyHandles PASS \n");
- }
- else {
+ } else {
printf("Authenticator Metadata maxKeyHandles FAIL \n");
//goto ERR;
}
if (authInfo->__meta->transactionConfirmationDisplay == auth->__meta->transactionConfirmationDisplay) {
printf("Authenticator Metadata transactionConfirmationDisplay PASS \n");
- }
- else {
+ } else {
printf("Authenticator Metadata transactionConfirmationDisplay FAIL \n");
//goto ERR;
}
if (authInfo->__meta->userVerification == auth->__meta->userVerification) {
printf("Authenticator Metadata userVerification PASS \n");
- }
- else {
+ } else {
printf("Authenticator Metadata userVerification FAIL \n");
//goto ERR;
}
if (authInfo->__tcDisplayPNGCharacteristics != NULL) {
printf("Non NULL tcDisplayPNGCharacteristics value PASS \n");
- }
- else {
+ } else {
printf("Non NULL tcDisplayPNGCharacteristics value FAIL \n");
goto ERR;
}
tcDisp = (DisplayTc*)(g_list_first(authInfo->__tcDisplayPNGCharacteristics)->data);
- if(tcDisp->width == disp->width) {
+ if (tcDisp->width == disp->width) {
printf("Authenticator tcDisplayPNGCharacteristics width PASS \n");
- }
- else {
+ } else {
printf("Authenticator tcDisplayPNGCharacteristics width FAIL \n");
}
- if(tcDisp->height == disp->height) {
+ if (tcDisp->height == disp->height) {
printf("Authenticator tcDisplayPNGCharacteristics height PASS \n");
- }
- else {
+ } else {
printf("Authenticator tcDisplayPNGCharacteristics height FAIL \n");
}
- if(tcDisp->bitDepth == disp->bitDepth) {
+ if (tcDisp->bitDepth == disp->bitDepth) {
printf("Authenticator tcDisplayPNGCharacteristics bitDepth PASS \n");
- }
- else {
+ } else {
printf("Authenticator tcDisplayPNGCharacteristics bitDepth FAIL \n");
}
- if(tcDisp->colorType == disp->colorType) {
+ if (tcDisp->colorType == disp->colorType) {
printf("Authenticator tcDisplayPNGCharacteristics colorType PASS \n");
- }
- else {
+ } else {
printf("Authenticator tcDisplayPNGCharacteristics colorType FAIL \n");
}
- if(tcDisp->compression == disp->compression) {
+ if (tcDisp->compression == disp->compression) {
printf("Authenticator tcDisplayPNGCharacteristics compression PASS \n");
- }
- else {
+ } else {
printf("Authenticator tcDisplayPNGCharacteristics compression FAIL \n");
}
- if(tcDisp->filter == disp->filter) {
+ if (tcDisp->filter == disp->filter) {
printf("Authenticator tcDisplayPNGCharacteristics filter PASS \n");
- }
- else {
+ } else {
printf("Authenticator tcDisplayPNGCharacteristics filter FAIL \n");
}
- if(tcDisp->interlace == disp->interlace) {
+ if (tcDisp->interlace == disp->interlace) {
printf("Authenticator tcDisplayPNGCharacteristics interlace PASS \n");
- }
- else {
+ } else {
printf("Authenticator tcDisplayPNGCharacteristics interlace FAIL \n");
}
if (strcmp(tcDisp->plte, disp->plte) == 0) {
printf("plte PASS \n");
- }
- else {
+ } else {
printf("plte FAIL \n");
}
int ret = encodableReq.setEncoder(EID_UAFV1_REGISTER_REQ);
if (ret == 0) {
printf("setEncoder EID_UAFV1_REGISTER_REQ PASS \n");
- }
- else {
+ } else {
printf("setEncoder EID_UAFV1_REGISTER_REQ FAIL \n");
goto ERR;
}
if (getRegReqBuff != 0) {
printf("encode EID_UAFV1_REGISTER_REQ PASS \n");
print_hex(getRegReqBuff);
- }
- else {
+ } else {
printf("encode EID_UAFV1_REGISTER_REQ FAIL \n");
goto ERR;
}
getRegReqInfo = encodableReq.decode(getRegReqBuff->data);
if (getRegReqInfo != NULL) {
printf("decode EID_UAFV1_REGISTER_REQ PASS \n");
- }
- else {
+ } else {
printf("decode EID_UAFV1_REGISTER_REQ FAIL \n");
goto ERR;
}
//===================================COMPARE==============================//
- if(getRegReqInfo->authIdx == getRegReq->authIdx) {
+ if (getRegReqInfo->authIdx == getRegReq->authIdx) {
printf("AUTHENTICATOR INDEX PASS \n");
- }
- else {
+ } else {
printf("AUTHENTICATOR INDEX FAIL \n");
goto ERR;
}
if (strcmp(getRegReqInfo->appId, getRegReq->appId) == 0) {
printf("APPID PASS \n");
- }
- else {
+ } else {
printf("APPID FAIL \n");
goto ERR;
}
if (memcmp(getRegReqInfo->fch->data, getRegReq->fch->data, getRegReq->fch->len) == 0) {
printf("FINAL CHALLENGE PASS \n");
- }
- else {
+ } else {
printf("FINAL CHALLENGE FAIL \n");
goto ERR;
}
if (strcmp(getRegReqInfo->userName, getRegReq->userName) == 0) {
printf("USERNAME PASS \n");
- }
- else {
+ } else {
printf("USERNAME FAIL \n");
goto ERR;
}
- if(getRegReqInfo->attType == getRegReq->attType) {
+ if (getRegReqInfo->attType == getRegReq->attType) {
printf("ATTESTATION TYPE PASS \n");
- }
- else {
+ } else {
printf("ATTESTATION TYPE FAIL \n");
goto ERR;
}
if (memcmp(getRegReqInfo->khAccessToken->data, getRegReq->khAccessToken->data, getRegReq->khAccessToken->len) == 0) {
printf("KEY HANDLE ACCESS TOKEN PASS \n");
- }
- else {
+ } else {
printf("KEY HANDLE ACCESS TOKEN FAIL \n");
goto ERR;
}
if (strcmp(getRegReqInfo->userVToken, getRegReq->userVToken) == 0) {
printf("USER VERIFICATION TOKEN PASS \n");
- }
- else {
+ } else {
printf("USER VERIFICATION TOKEN FAIL \n");
goto ERR;
}
int ret = encodableRegResp.setEncoder(EID_UAFV1_REGISTER_RESP);
if (ret == 0) {
printf("setEncoder EID_UAFV1_REGISTER_RESP PASS \n");
- }
- else {
+ } else {
printf("setEncoder EID_UAFV1_REGISTER_RESP FAIL \n");
goto ERR;
}
if (getRegRespBuff != NULL) {
printf("encode EID_UAFV1_REGISTER_RESP PASS \n");
print_hex(getRegRespBuff);
- }
- else {
+ } else {
printf("encode EID_UAFV1_REGISTER_RESP FAIL \n");
goto ERR;
}
getRegRespInfo = encodableRegResp.decode(getRegRespBuff->data);
if (getRegRespInfo != NULL) {
printf("decode EID_UAFV1_REGISTER_RESP PASS \n");
- }
- else {
+ } else {
printf("decode EID_UAFV1_REGISTER_RESP FAIL \n");
goto ERR;
}
if (getRegRespInfo->statusCode == getRegResp->statusCode) {
printf("statusCode EID_UAFV1_REGISTER_RESP PASS \n");
- }
- else {
+ } else {
printf("statusCode EID_UAFV1_REGISTER_RESP FAIL \n");
goto ERR;
}
if (strcmp(getRegRespInfo->regAssertion->krd->aaid, getRegResp->regAssertion->krd->aaid) == 0) {
printf("AAID EID_UAFV1_REGISTER_RESP PASS \n");
- }
- else {
+ } else {
printf("AAID EID_UAFV1_REGISTER_RESP FAIL \n");
goto ERR;
}
if (getRegRespInfo->regAssertion->krd->assrtInfo->authVersion == getRegResp->regAssertion->krd->assrtInfo->authVersion) {
printf("AuthVersion EID_UAFV1_REGISTER_RESP PASS \n");
- }
- else {
+ } else {
printf("AuthVersion EID_UAFV1_REGISTER_RESP FAIL \n");
goto ERR;
}
if (getRegRespInfo->regAssertion->krd->assrtInfo->authMode == getRegResp->regAssertion->krd->assrtInfo->authMode) {
printf("AuthMode EID_UAFV1_REGISTER_RESP PASS \n");
- }
- else {
+ } else {
printf("AuthMode EID_UAFV1_REGISTER_RESP FAIL \n");
goto ERR;
}
if (getRegRespInfo->regAssertion->krd->assrtInfo->signatureAlgAndEncoding == getRegResp->regAssertion->krd->assrtInfo->signatureAlgAndEncoding) {
printf("signatureAlgAndEncoding EID_UAFV1_REGISTER_RESP PASS \n");
- }
- else {
+ } else {
printf("signatureAlgAndEncoding EID_UAFV1_REGISTER_RESP FAIL \n");
goto ERR;
}
if (getRegRespInfo->regAssertion->krd->assrtInfo->publicKeyAlgAndEncoding == getRegResp->regAssertion->krd->assrtInfo->publicKeyAlgAndEncoding) {
printf("publicKeyAlgAndEncoding EID_UAFV1_REGISTER_RESP PASS \n");
- }
- else {
+ } else {
printf("publicKeyAlgAndEncoding EID_UAFV1_REGISTER_RESP FAIL \n");
goto ERR;
}
if (memcmp(getRegRespInfo->regAssertion->krd->fch->data , getRegResp->regAssertion->krd->fch->data,
getRegResp->regAssertion->krd->fch->len) == 0) {
printf("fch EID_UAFV1_REGISTER_RESP PASS \n");
- }
- else {
+ } else {
printf("fch EID_UAFV1_REGISTER_RESP FAIL \n");
goto ERR;
}
if (memcmp(getRegRespInfo->regAssertion->krd->keyId->data ,
getRegResp->regAssertion->krd->keyId->data, getRegResp->regAssertion->krd->keyId->len) == 0) {
printf("keyId EID_UAFV1_REGISTER_RESP PASS \n");
- }
- else {
+ } else {
printf("keyId EID_UAFV1_REGISTER_RESP FAIL \n");
goto ERR;
}
if (getRegRespInfo->regAssertion->krd->counter->regCounter == getRegResp->regAssertion->krd->counter->regCounter) {
printf("regCounter EID_UAFV1_REGISTER_RESP PASS \n");
- }
- else {
+ } else {
printf("regCounter EID_UAFV1_REGISTER_RESP FAIL \n");
goto ERR;
}
if (getRegRespInfo->regAssertion->krd->counter->signCounter == getRegResp->regAssertion->krd->counter->signCounter) {
printf("signCounter EID_UAFV1_REGISTER_RESP PASS \n");
- }
- else {
+ } else {
printf("signCounter EID_UAFV1_REGISTER_RESP FAIL \n");
goto ERR;
}
if (memcmp(getRegRespInfo->regAssertion->krd->pubKey->data ,
getRegResp->regAssertion->krd->pubKey->data, getRegResp->regAssertion->krd->pubKey->len) == 0) {
printf("pubKey EID_UAFV1_REGISTER_RESP PASS \n");
- }
- else {
+ } else {
printf("pubKey EID_UAFV1_REGISTER_RESP FAIL \n");
goto ERR;
}
if (memcmp(getRegRespInfo->regAssertion->attFull->sig->data ,
getRegResp->regAssertion->attFull->sig->data, getRegResp->regAssertion->attFull->sig->len) == 0) {
printf("attFull->sig EID_UAFV1_REGISTER_RESP PASS \n");
- }
- else {
+ } else {
printf("attFull->sig EID_UAFV1_REGISTER_RESP FAIL \n");
goto ERR;
}
if (memcmp(getRegRespInfo->regAssertion->attFull->cert->data ,
getRegResp->regAssertion->attFull->cert->data, getRegResp->regAssertion->attFull->cert->len) == 0) {
printf("attFull->cert EID_UAFV1_REGISTER_RESP PASS \n");
- }
- else {
+ } else {
printf("attFull->cert EID_UAFV1_REGISTER_RESP FAIL \n");
goto ERR;
}
if (memcmp(getRegRespInfo->kh->data ,
getRegResp->kh->data, getRegResp->kh->len) == 0) {
printf("keyHandle EID_UAFV1_REGISTER_RESP PASS \n");
- }
- else {
+ } else {
printf("keyHandle EID_UAFV1_REGISTER_RESP FAIL \n");
goto ERR;
}
int ret = encodableSignReq.setEncoder(EID_UAFV1_SIGN_REQ);
if (ret == 0) {
printf("setEncoder EID_UAFV1_SIGN_REQ PASS \n");
- }
- else {
+ } else {
printf("setEncoder EID_UAFV1_SIGN_REQ FAIL \n");
goto ERR;
}
if (getAuthReqInfoBuff != NULL) {
printf("encode EID_UAFV1_SIGN_REQ PASS \n");
print_hex(getAuthReqInfoBuff);
- }
- else {
+ } else {
printf("encode EID_UAFV1_SIGN_REQ FAIL \n");
goto ERR;
}
getAuthReqInfo = encodableSignReq.decode(getAuthReqInfoBuff->data);
if (getAuthReqInfo != NULL) {
printf("decode EID_UAFV1_SIGN_REQ PASS \n");
- }
- else {
+ } else {
printf("decode EID_UAFV1_SIGN_REQ FAIL \n");
goto ERR;
}
if (getAuthReqInfo->authIdx == getAuthReq->authIdx) {
printf("authIdx EID_UAFV1_SIGN_REQ PASS \n");
- }
- else {
+ } else {
printf("authIdx EID_UAFV1_SIGN_REQ FAIL \n");
goto ERR;
}
if (strcmp(getAuthReqInfo->appId, getAuthReq->appId) == 0) {
printf("appId EID_UAFV1_SIGN_REQ PASS \n");
- }
- else {
+ } else {
printf("appId EID_UAFV1_SIGN_REQ FAIL \n");
goto ERR;
}
if (memcmp(getAuthReqInfo->fch->data, getAuthReq->fch->data, getAuthReq->fch->len) == 0) {
printf("fch EID_UAFV1_SIGN_REQ PASS \n");
- }
- else {
+ } else {
printf("appId EID_UAFV1_SIGN_REQ FAIL \n");
goto ERR;
}
if (strcmp(getAuthReqInfo->tc, getAuthReq->tc) == 0) {
printf("tc EID_UAFV1_SIGN_REQ PASS \n");
- }
- else {
+ } else {
printf("tc EID_UAFV1_SIGN_REQ FAIL \n");
goto ERR;
}
if (memcmp(getAuthReqInfo->khATok->data, getAuthReq->khATok->data, getAuthReq->khATok->len) == 0) {
printf("khATok EID_UAFV1_SIGN_REQ PASS \n");
- }
- else {
+ } else {
printf("khATok EID_UAFV1_SIGN_REQ FAIL \n");
goto ERR;
}
if (strcmp(getAuthReqInfo->userVToken, getAuthReq->userVToken) == 0) {
printf("userVToken EID_UAFV1_SIGN_REQ PASS \n");
- }
- else {
+ } else {
printf("userVToken EID_UAFV1_SIGN_REQ FAIL \n");
goto ERR;
}
int ret = encodableSignResp.setEncoder(EID_UAFV1_SIGN_RESP);
if (ret == 0) {
printf("setEncoder EID_UAFV1_SIGN_RESP PASS \n");
- }
- else {
+ } else {
printf("setEncoder EID_UAFV1_SIGN_RESP FAIL \n");
goto ERR;
}
if (getAuthRespInfoBuff != NULL) {
printf("encode EID_UAFV1_SIGN_RESP PASS \n");
print_hex(getAuthRespInfoBuff);
- }
- else {
+ } else {
printf("encode EID_UAFV1_SIGN_RESP FAIL \n");
goto ERR;
}
getAuthRespInfo = encodableSignResp.decode(getAuthRespInfoBuff->data);
if (getAuthRespInfo != NULL) {
printf("decode EID_UAFV1_SIGN_RESP PASS \n");
- }
- else {
+ } else {
printf("decode EID_UAFV1_SIGN_RESP FAIL \n");
goto ERR;
}
if (getAuthRespInfo->statusCode == getAuthResp->statusCode) {
printf("statusCode EID_UAFV1_SIGN_RESP PASS \n");
- }
- else {
+ } else {
printf("statusCode EID_UAFV1_SIGN_RESP FAIL \n");
goto ERR;
}
if (strcmp(getAuthRespInfo->authAssertion->sigData->aaid, getAuthResp->authAssertion->sigData->aaid) == 0) {
printf("aaid EID_UAFV1_SIGN_RESP PASS \n");
- }
- else {
+ } else {
printf("aaid EID_UAFV1_SIGN_RESP FAIL \n");
goto ERR;
}
if (getAuthRespInfo->authAssertion->sigData->assrtInfo->authVersion == getAuthResp->authAssertion->sigData->assrtInfo->authVersion) {
printf("authVersion EID_UAFV1_SIGN_RESP PASS \n");
- }
- else {
+ } else {
printf("authVersion EID_UAFV1_SIGN_RESP FAIL \n");
goto ERR;
}
if (getAuthRespInfo->authAssertion->sigData->assrtInfo->authMode == getAuthResp->authAssertion->sigData->assrtInfo->authMode) {
printf("authMode EID_UAFV1_SIGN_RESP PASS \n");
- }
- else {
+ } else {
printf("authMode EID_UAFV1_SIGN_RESP FAIL \n");
goto ERR;
}
if (getAuthRespInfo->authAssertion->sigData->assrtInfo->signatureAlgAndEncoding == getAuthResp->authAssertion->sigData->assrtInfo->signatureAlgAndEncoding) {
printf("signatureAlgAndEncoding EID_UAFV1_SIGN_RESP PASS \n");
- }
- else {
+ } else {
printf("signatureAlgAndEncoding EID_UAFV1_SIGN_RESP FAIL \n");
goto ERR;
}
if (memcmp(getAuthRespInfo->authAssertion->sigData->authNonce->data,
getAuthResp->authAssertion->sigData->authNonce->data, getAuthResp->authAssertion->sigData->authNonce->len) == 0) {
printf("authNonce EID_UAFV1_SIGN_RESP PASS \n");
- }
- else {
+ } else {
printf("authNonce EID_UAFV1_SIGN_RESP FAIL \n");
goto ERR;
}
if (memcmp(getAuthRespInfo->authAssertion->sigData->fch->data, getAuthResp->authAssertion->sigData->fch->data,
getAuthResp->authAssertion->sigData->fch->len) == 0) {
printf("fch EID_UAFV1_SIGN_RESP PASS \n");
- }
- else {
+ } else {
printf("fch EID_UAFV1_SIGN_RESP FAIL \n");
goto ERR;
}
if (memcmp(getAuthRespInfo->authAssertion->sigData->tcHash->data,
getAuthResp->authAssertion->sigData->tcHash->data, getAuthResp->authAssertion->sigData->tcHash->len) == 0) {
printf("tcHash EID_UAFV1_SIGN_RESP PASS \n");
- }
- else {
+ } else {
printf("tcHash EID_UAFV1_SIGN_RESP FAIL \n");
goto ERR;
}
if (memcmp(getAuthRespInfo->authAssertion->sigData->keyId->data,
getAuthResp->authAssertion->sigData->keyId->data, getAuthResp->authAssertion->sigData->keyId->len) == 0) {
printf("keyId EID_UAFV1_SIGN_RESP PASS \n");
- }
- else {
+ } else {
printf("keyId EID_UAFV1_SIGN_RESP FAIL \n");
goto ERR;
}
if (getAuthRespInfo->authAssertion->sigData->counter->signCounter == getAuthResp->authAssertion->sigData->counter->signCounter) {
printf("signCounter EID_UAFV1_SIGN_RESP PASS \n");
- }
- else {
+ } else {
printf("signCounter EID_UAFV1_SIGN_RESP FAIL \n");
goto ERR;
}
if (memcmp(getAuthRespInfo->authAssertion->sig->data,
getAuthResp->authAssertion->sig->data, getAuthResp->authAssertion->sig->len) == 0) {
printf("signature EID_UAFV1_SIGN_RESP PASS \n");
- }
- else {
+ } else {
printf("signature EID_UAFV1_SIGN_RESP FAIL \n");
goto ERR;
}
int ret = encodableDeRegReq.setEncoder(EID_UAFV1_DEREG_REQ);
if (ret == 0) {
printf("setEncoder EID_UAFV1_DEREG_REQ PASS \n");
- }
- else {
+ } else {
printf("setEncoder EID_UAFV1_DEREG_REQ FAIL \n");
goto ERR;
}
if (getDeRegReqInfoBuff != NULL) {
printf("encode EID_UAFV1_DEREG_REQ PASS \n");
print_hex(getDeRegReqInfoBuff);
- }
- else {
+ } else {
printf("encode EID_UAFV1_DEREG_REQ FAIL \n");
goto ERR;
}
getDeRegReqInfo = encodableDeRegReq.decode(getDeRegReqInfoBuff->data);
if (getDeRegReqInfo != NULL) {
printf("decode EID_UAFV1_DEREG_REQ PASS \n");
- }
- else {
+ } else {
printf("decode EID_UAFV1_DEREG_REQ FAIL \n");
goto ERR;
}
if (getDeRegReq->authIdx == getDeRegReqInfo->authIdx) {
printf("authIdx EID_UAFV1_DEREG_REQ PASS \n");
- }
- else {
+ } else {
printf("authIdx EID_UAFV1_DEREG_REQ FAIL \n");
goto ERR;
}
if (strcmp(getDeRegReq->appId, getDeRegReqInfo->appId) == 0) {
printf("appId EID_UAFV1_DEREG_REQ PASS \n");
- }
- else {
+ } else {
printf("appId EID_UAFV1_DEREG_REQ FAIL \n");
goto ERR;
}
if (strcmp(getDeRegReq->keyId, getDeRegReqInfo->keyId) == 0) {
printf("keyId EID_UAFV1_DEREG_REQ PASS \n");
- }
- else {
+ } else {
printf("keyId EID_UAFV1_DEREG_REQ FAIL \n");
goto ERR;
}
if (memcmp(getDeRegReq->khATok->data, getDeRegReqInfo->khATok->data, getDeRegReqInfo->khATok->len) == 0) {
printf("khATok EID_UAFV1_DEREG_REQ PASS \n");
- }
- else {
+ } else {
printf("khATok EID_UAFV1_DEREG_REQ FAIL \n");
goto ERR;
}
ERR:
printf("==============testTLV DEREGISTER REQUEST end============== \n");
get_user_choice();
-
}
void
int ret = encodableDeRegResp.setEncoder(EID_UAFV1_DEREG_RESP);
if (ret == 0) {
printf("setEncoder EID_UAFV1_DEREG_RESP PASS \n");
- }
- else {
+ } else {
printf("setEncoder EID_UAFV1_DEREG_RESP FAIL \n");
goto ERR;
}
if (getDeRegRespInfoBuff != NULL) {
printf("encode EID_UAFV1_DEREG_RESP PASS \n");
print_hex(getDeRegRespInfoBuff);
- }
- else {
+ } else {
printf("encode EID_UAFV1_DEREG_REQ FAIL \n");
goto ERR;
}
getDeRegRespInfo = encodableDeRegResp.decode(getDeRegRespInfoBuff->data);
if (getDeRegRespInfo != NULL) {
printf("decode EID_UAFV1_DEREG_RESP PASS \n");
- }
- else {
+ } else {
printf("decode EID_UAFV1_DEREG_REQ FAIL \n");
goto ERR;
}
if (getDeRegRespInfo->statusCode == getDeRegResp->statusCode) {
printf("statusCode EID_UAFV1_DEREG_RESP PASS \n");
- }
- else {
+ } else {
printf("statusCode EID_UAFV1_DEREG_REQ FAIL \n");
goto ERR;
}
AuthenrStub *authStub = *it;
if (authStub == NULL) {
printf("authStub FAILED\n");
- }
- else {
+ } else {
int ret = authStub->connect();
if (ret != 0) {
printf("AuthenrStub::connect FAILED\n");
- }
- else {
+ } else {
printf("AuthenrStub::connect PASS\n");
}
}
//DELETE DATA
int ret = obj->deleteData(parcel);
- if(ret == 0) {
+ if (ret == 0) {
printf("Records successfully deleted\n");
- }
- else if(ret == 1) {
+ } else if (ret == 1) {
printf("Records not deleted/ does not exists\n");
}
}
parcel->setString(STR_PROP_KEY_ID, keyId);
int ret = obj->deleteData(parcel);
- if(ret == 0) {
+ if (ret == 0) {
printf("Records successfully deleted\n");
- }
- else if(ret == 1) {
+ } else if (ret == 1) {
printf("Records not deleted/ does not exists\n");
}
}
bulkData.push_back(parcel1);
int ret = obj->insertBulkData(&bulkData);
- if(ret == 0) {
+ if (ret == 0) {
printf("Records successfully inserted\n");
- }
- else if(ret == 1) {
+ } else if (ret == 1) {
printf("Records not inserted/ already exists\n");
}
if (ver->getMajor() == 1) {
printf("getMajor PASSED \n");
- }
- else {
+ } else {
printf("getMajor FAILED \n");
}
if (ver->getMinor() == 0) {
printf("getMinor PASSED \n");
- }
- else {
+ } else {
printf("getMinor FAILED \n");
}
if (asmReq->getRequesttype() == expReqType) {
printf("getRequesttype PASSED \n");
- }
- else {
+ } else {
printf("getRequesttype FAILED \n");
}
if (asmReqReg->getAuthIndex() == 1) {
printf("getAuthIndex PASSED \n");
- }
- else {
+ } else {
printf("getAuthIndex FAILED \n");
}
if (regArg->getAppId() == "https://qa-egypt.noknoktest.com:443/UAFSampleProxy/uaf/facets.uaf") {
printf("getAppId PASSED \n");
- }
- else {
+ } else {
printf("getAppId FAILED \n");
}
if (regArg->getUserName() == "user1") {
printf("getUserName PASSED \n");
- }
- else {
+ } else {
printf("getUserName FAILED \n");
}
if (regArg->getFinalChallenge() == "eyJhcHBJRCI6Imh0dHBzOi8vcWEtZWd5cHQubm9rbm9rdGVzdC5jb206NDQzL1VBRlNhbXBsZVByb3h5L3VhZi9mYWNldHMudWFmIiwiY2hhbGxlbmdlIjoidVlCdUdRZjdyLUxORDE2UTBHVXBQUmkxMTJVakN0Y3ltM2F3am0tTW1tSSIsImNoYW5uZWxCaW5kaW5nIjp7fSwiZmFjZXRJRCI6ImNvbS5ub2tub2suYW5kcm9pZC5zYW1wbGVhcHAifQ") {
printf("getFinalChallenge PASSED \n");
- }
- else {
+ } else {
printf("getFinalChallenge FAILED \n");
}
if (regArg->getAttestationType() == 15879) {
printf("getAttestationType PASSED \n");
- }
- else {
+ } else {
printf("getAttestationType FAILED \n");
}
if (asmReqAuth->getAuthIndex() == 1) {
printf("getAuthIndex PASSED \n");
- }
- else {
+ } else {
printf("getAuthIndex FAILED \n");
}
if (authArg->getAppId() == "https://qa-egypt.noknoktest.com:443/UAFSampleProxy/uaf/facets.uaf") {
printf("getAppId PASSED \n");
- }
- else {
+ } else {
printf("getAppId FAILED \n");
}
if (authArg->getFCH() == "eyJhcHBJRCI6Imh0dHBzOi8vcWEtZWd5cHQubm9rbm9rdGVzdC5jb206NDQzL1VBRlNhbXBsZVByb3h5L3VhZi9mYWNldHMudWFmIiwiY2hhbGxlbmdlIjoiM3otaVN2TndENFFLd01kV1NCS0hGT2hNNDN4M1dGOHI1eU9yd0pmVzljSSIsImNoYW5uZWxCaW5kaW5nIjp7fSwiZmFjZXRJRCI6ImNvbS5ub2tub2suYW5kcm9pZC5zYW1wbGVhcHAifQ") {
printf("getFCH PASSED \n");
- }
- else {
+ } else {
printf("getFCH FAILED \n");
}
if (asmReqDereg->getAuthIndex() == 1) {
printf("getAuthIndex PASSED \n");
- }
- else {
+ } else {
printf("getAuthIndex FAILED \n");
}
if (deregArg->getAppId() == "https://qa-egypt.noknoktest.com:443/UAFSampleProxy/uaf/facets.uaf") {
printf("getAppId PASSED \n");
- }
- else {
+ } else {
printf("getAppId FAILED \n");
}
if (deregArg->getKeyId() == "1eVp7JIQlwm6YF0YEmGZdNCA27qZoIcZGC0Uaw71bR8") {
printf("getKeyId PASSED \n");
- }
- else {
+ } else {
printf("getKeyId FAILED \n");
}
char *
compose_asm_dereg_request(char *appId, char *keyId, int authIdx)
{
-
JsonBuilder *builder = json_builder_new();
json_builder_begin_object(builder);
const char *asmReqJson = compose_asm_dereg_request(appId, kId, 1);
- if(asmReqJson != NULL) {
+ if (asmReqJson != NULL) {
const std::string callerId = "caller_id";
AsmRequest *req = JsonUtil::parseAsmRequestJson(asmReqJson);
char *asmResp = operation->execute();
printf("\n\nASM DEREGISTER RESPONSE : [%s]\n\n", asmResp);
- }
- else {
+ } else {
printf("ERROR : ASM DEREGISTER REQ JSON IS NULL");
return 1;
}
strcpy(appId, "https://qa-egypt.noknoktest.com:443/UAFSampleProxy/uaf/facets.uaf");
char *fc = (char*)calloc(1, 5000);
- strcpy(fc,"eyJhcHBJRCI6Imh0dHBzOi8vcWEtZWd5cHQubm9rbm9rdGVzdC5jb206NDQzL1VBRlNhbXBsZVByb3h5L3VhZi9mYWNldHMudWFmIiwiY2hhbGxlbmdlIjoiM3otaVN2TndENFFLd01kV1NCS0hGT2hNNDN4M1dGOHI1eU9yd0pmVzljSSIsImNoYW5uZWxCaW5kaW5nIjp7fSwiZmFjZXRJRCI6ImNvbS5ub2tub2suYW5kcm9pZC5zYW1wbGVhcHAifQ");
+ strcpy(fc, "eyJhcHBJRCI6Imh0dHBzOi8vcWEtZWd5cHQubm9rbm9rdGVzdC5jb206NDQzL1VBRlNhbXBsZVByb3h5L3VhZi9mYWNldHMudWFmIiwiY2hhbGxlbmdlIjoiM3otaVN2TndENFFLd01kV1NCS0hGT2hNNDN4M1dGOHI1eU9yd0pmVzljSSIsImNoYW5uZWxCaW5kaW5nIjp7fSwiZmFjZXRJRCI6ImNvbS5ub2tub2suYW5kcm9pZC5zYW1wbGVhcHAifQ");
const char *asmReqJson = compose_asm_auth_req_json(appId, kId, fc, 1);
- if(asmReqJson != NULL) {
+ if (asmReqJson != NULL) {
const std::string callerId = "caller_id";
AsmRequest *req = JsonUtil::parseAsmRequestJson(asmReqJson);
char *asmResp = operation->execute();
printf("\n\nASM AUTHENTICATE RESPONSE : [%s]\n\n", asmResp);
- }
- else {
+ } else {
printf("ERROR : ASM AUTH REQ JSON IS NULL");
return 1;
}
resDataObj = json_object_get_object_member(root_obj, "responseData");
- if(resDataObj != NULL)
+ if (resDataObj != NULL)
{
const char *regAssrtn_temp = json_object_get_string_member(resDataObj, "assertion");
int ret = encodableRegAssrtn.setEncoder(EID_UAFV1_REG_ASSERTION_RESP);
if (ret == 0) {
printf("setEncoder EID_UAFV1_REG_ASSERTION_RESP PASS \n");
- }
- else {
+ } else {
printf("setEncoder EID_UAFV1_REG_ASSERTION_RESP FAIL \n");
return NULL;
}
getRegAssrtnInfo = encodableRegAssrtn.decode(testBuff->data);
if (getRegAssrtnInfo != NULL) {
printf("decode EID_UAFV1_REG_ASSERTION_RESP PASS \n");
- }
- else {
+ } else {
printf("decode EID_UAFV1_REG_ASSERTION_RESP FAIL \n");
return NULL;
}
printf("ASM GETINFO RESPOMSE : [%s]\n\n", asmResp);
printf("==============testOp GETINFO end============== \n\n\n");
-
}
void
Buffer *keyId = NULL;
keyId = testOpReg();
- if(keyId != NULL) {
+ if (keyId != NULL) {
ret = testOpAuth(keyId);
- }
- else {
+ } else {
printf("Key Id obtaibed from Registeration process is NULL\n");
}
- if(ret == 0) {
+ if (ret == 0) {
printf("User Authenticated :: SUCCESS\n");
testOpDeReg(keyId);
- }
- else {
+ } else {
printf("User Authenticated :: FAIL\n");
}
#include <string.h>
#include <stdio.h>
-bool
+bool
show_confirm_dialog(const char *title)
{
const int options[2] = {1, 2};
return answer;
}
-int
+int
show_menu(
const char *title,
const int *options,
* otherwise a negative error value
*/
int show_menu(
- const char *title,
- const int *options,
- const char **names,
- int number_of_option);
+ const char *title,
+ const int *options,
+ const char **names,
+ int number_of_option);
#endif /* __FIDO_SHELL_TC_UTIL_H_ */
/*Toolbar*/
Evas_Object *toolbar = ui_utils_toolbar_add_tc(__ad->nf);
- if(toolbar) {
+ if (toolbar) {
evas_object_show(toolbar);
elm_toolbar_select_mode_set(toolbar, ELM_OBJECT_SELECT_MODE_NONE);
/*Toolbar*/
Evas_Object *toolbar = ui_utils_toolbar_add_account(__ad->nf);
- if(toolbar) {
+ if (toolbar) {
evas_object_show(toolbar);
elm_toolbar_select_mode_set(toolbar, ELM_OBJECT_SELECT_MODE_NONE);
int
genB64Encode(const unsigned char *input, int inlen, unsigned char * output, int *outlen)
{
-#if 0
- EVP_ENCODE_CTX ctx;
- int t = 0;
- EVP_EncodeInit(&ctx);
- EVP_EncodeUpdate(&ctx, output,outlen,input,inlen);
- EVP_EncodeFinal(&ctx,output + *outlen, &t);
- *outlen += t -1;
-#else
BIO * bmem = NULL;
BIO * b64 = NULL;
BUF_MEM * bptr = NULL;
b64 = BIO_new(BIO_f_base64());
- if(b64 == NULL)
- {
+ if (b64 == NULL) {
_ERR("BIO_new failed \n");
return -1;
}
memcpy(output, bptr->data, bptr->length);
output[bptr->length] = 0;
*outlen = bptr->length;
- if(b64)
- {
+ if (b64) {
BIO_free_all(b64);
}
- //printf("outlen is %d, out is %s\n",*outlen, output);
-#endif
+
int i;
- for(i =0; i < *outlen ; i++)
- {
- if(output[i] == '+')
- {
+ for (i = 0; i < *outlen ; i++) {
+ if (output[i] == '+') {
output[i] = '-';
- }
- else if(output[i] == '/')
- {
+ } else if (output[i] == '/') {
output[i] = '_';
- }
- else if(output[i] == '=')
- {
+ } else if (output[i] == '=') {
*outlen = i ;
output[i] = '\0';
break;
if (0 != genB64Encode(input,
inputSz,
output,
- &outputSz))
- {
+ &outputSz)) {
_ERR("Failed to encode base64.");
free(output);
return (unsigned char*)"";
genHash256(const void* input, unsigned long length, unsigned char* md)
{
SHA256_CTX context;
- if(!SHA256_Init(&context))
+ if (!SHA256_Init(&context))
return false;
- if(!SHA256_Update(&context, (unsigned char*)input, length))
+ if (!SHA256_Update(&context, (unsigned char*)input, length))
return false;
- if(!SHA256_Final(md, &context))
+ if (!SHA256_Final(md, &context))
return false;
return true;
static void
pin_save_clicked(void *data, Evas_Object *obj, void *event_info)
{
- if(elm_entry_is_empty(__ad->entry) == EINA_TRUE){
+ if (elm_entry_is_empty(__ad->entry) == EINA_TRUE) {
toast_popup("Enter PIN");
return;
}
if (strcmp(pin_b64, __ad->token_in) == 0) {
asm_ui_ipc_send_auth_result(0, __ad->nonce, 0, pin);
- }
- else {
+ } else {
dlog_print(DLOG_INFO, "org.tizen.asmui", "fido asm ui [%s][%s][%s]", pin, pin_b64, __ad->token_in);
toast_popup("Incorrect PIN");
return;
/*Toolbar*/
Evas_Object *toolbar = ui_utils_toolbar_add_account(__ad->nf);
- if(toolbar) {
+ if (toolbar) {
evas_object_show(toolbar);
elm_toolbar_select_mode_set(toolbar, ELM_OBJECT_SELECT_MODE_NONE);
ui_app_add_event_handler(&handlers[APP_EVENT_REGION_FORMAT_CHANGED], APP_EVENT_REGION_FORMAT_CHANGED, ui_app_region_changed, __ad);
ui_app_remove_event_handler(handlers[APP_EVENT_LOW_MEMORY]);
-#if !GLIB_CHECK_VERSION(2,35,0)
+#if !GLIB_CHECK_VERSION(2, 35, 0)
g_type_init();
#endif
NULL,
&error);
- if (error != NULL) {
+ if (error != NULL)
dlog_print(DLOG_INFO, "org.tizen.asmui", "fido asm ui after fidoasm_proxy_new_sync %s", error->message);
- }
+
return dbus_proxy;
}
GError *err = NULL;
fidoasm_call_asm_ui_confirm_tc_sync(dbus_proxy, nonce, result, NULL, &err);
dlog_print(DLOG_INFO, "org.tizen.asmui", "fido asm ui after fidoasm_call_asm_ui_confirm_tc_sync");
- if (err != NULL) {
+ if (err != NULL)
dlog_print(DLOG_INFO, "org.tizen.asmui", "fido asm ui fidoasm_call_asm_ui_confirm_tc_sync %s", err->message);
- }
return 0;
}
projects / platform / core / account / fido-asm.git / commitdiff