From 027756c1637e6d506cf0a02a72d9670b41fa6c2c Mon Sep 17 00:00:00 2001 From: sirpy Date: Wed, 18 Oct 2023 21:14:59 +0300 Subject: [PATCH 01/12] wip: gender and age --- src/server/aws-rekognition/aws-rekognition.js | 41 +++++++++++++++++++ src/server/verification/verificationAPI.js | 40 +++++++++++++++++- 2 files changed, 80 insertions(+), 1 deletion(-) create mode 100644 src/server/aws-rekognition/aws-rekognition.js diff --git a/src/server/aws-rekognition/aws-rekognition.js b/src/server/aws-rekognition/aws-rekognition.js new file mode 100644 index 00000000..d3ee1a5d --- /dev/null +++ b/src/server/aws-rekognition/aws-rekognition.js @@ -0,0 +1,41 @@ +// @flow +import REK from 'aws-sdk/clients/rekognition' +import conf from '../server.config' + +const accessKeyId = conf.awsSesAccessKey +const secretAccessKey = conf.awsSesSecretAccessKey +const region = conf.awsSesRegion + +const runInEnv = ['production', 'staging'].includes(conf.env) + +if (runInEnv) { + if (!accessKeyId || !secretAccessKey || !region) { + throw new Error('Missing AWS configuration') + } +} + +const REK_CONFIG = { + accessKeyId, + secretAccessKey, + region +} + +const rek = new REK(REK_CONFIG) + +export const detectFaces = async imageBase64 => { + const buf = Buffer.from(imageBase64, 'base64') + const params = { + Image: { + /* required */ + Bytes: buf + }, + Attributes: ['AGE_RANGE', 'GENDER'] + } + try { + const result = await rek.detectFaces(params).promise() + console.log({ result }) + return result + } catch (e) { + console.log(e) + } +} diff --git a/src/server/verification/verificationAPI.js b/src/server/verification/verificationAPI.js index ce0df357..e3f9fb9b 100644 --- a/src/server/verification/verificationAPI.js +++ b/src/server/verification/verificationAPI.js @@ -13,13 +13,14 @@ import OTP from '../../imports/otp' import conf from '../server.config' import OnGage from '../crm/ongage' import { sendTemplateEmail } from '../aws-ses/aws-ses' +import { detectFaces } from '../aws-rekognition/aws-rekognition' import fetch from 'cross-fetch' - import createEnrollmentProcessor from './processor/EnrollmentProcessor.js' import { recoverPublickey } from '../utils/eth' import { shouldLogVerificaitonError } from './utils/logger' import { syncUserEmail } from '../storage/addUserSteps' import { FV_IDENTIFIER_MSG2 } from '../login/login-middleware' +import getZoomProvider from './processor/provider/ZoomProvider' const verifyFVIdentifier = async (identifier, gdAddress) => { //check v2, v2 identifier is expected to be the whole signature @@ -732,6 +733,43 @@ const setup = (app: Router, verifier: VerificationAPI, storage: StorageAPI) => { } }) ) + + app.post( + '/verify/agegender', + passport.authenticate('jwt', { session: false }), + requestRateLimiter(1, 1), + wrapAsync(async (req, res) => { + const { user, log } = req + let { v1Identifier, v2Identifier } = req.body + const { gdAddress } = user + + const zoomProvider = getZoomProvider() + + // for v2 identifier - verify that identifier is for the address we are going to whitelist + await verifyFVIdentifier(v2Identifier, gdAddress) + + v2Identifier = v2Identifier.slice(0, 42) + v1Identifier = v1Identifier.replace('0x', '') // wallet will also supply the v1 identifier as fvSigner, we remove '0x' for public address + + // here we check if wallet was registered using v1 of v2 identifier + const [recordV2, recordV1] = await Promise.all([ + zoomProvider.getEnrollment(v2Identifier, log), + v1Identifier && zoomProvider.getEnrollment(v1Identifier, log) + ]) + + const record = recordV2 || recordV1 + if (!record) throw new Error('face record not found') + const { auditTrailBase64 } = record + const { FaceDetails } = await detectFaces(auditTrailBase64) + log.info({ FaceDetails }) + await Promise.all([ + // semaphore.enrollAge(FaceDetails[0].AgeRange), + // semaphore.enrollGender(FaceDetails[0].Gender.Value) + ]) + + res.json({ ok: 1 }) + }) + ) } export default setup From 616616fa8a7d01423fb459623acdc08072aa5372 Mon Sep 17 00:00:00 2001 From: John Smith Date: Tue, 12 Mar 2024 01:14:19 +0200 Subject: [PATCH 02/12] add move/simplify aws client --- src/server/aws-rekognition/aws-rekognition.js | 41 ------------------- src/server/goodid/aws.js | 31 ++++++++++++++ 2 files changed, 31 insertions(+), 41 deletions(-) delete mode 100644 src/server/aws-rekognition/aws-rekognition.js create mode 100644 src/server/goodid/aws.js diff --git a/src/server/aws-rekognition/aws-rekognition.js b/src/server/aws-rekognition/aws-rekognition.js deleted file mode 100644 index d3ee1a5d..00000000 --- a/src/server/aws-rekognition/aws-rekognition.js +++ /dev/null @@ -1,41 +0,0 @@ -// @flow -import REK from 'aws-sdk/clients/rekognition' -import conf from '../server.config' - -const accessKeyId = conf.awsSesAccessKey -const secretAccessKey = conf.awsSesSecretAccessKey -const region = conf.awsSesRegion - -const runInEnv = ['production', 'staging'].includes(conf.env) - -if (runInEnv) { - if (!accessKeyId || !secretAccessKey || !region) { - throw new Error('Missing AWS configuration') - } -} - -const REK_CONFIG = { - accessKeyId, - secretAccessKey, - region -} - -const rek = new REK(REK_CONFIG) - -export const detectFaces = async imageBase64 => { - const buf = Buffer.from(imageBase64, 'base64') - const params = { - Image: { - /* required */ - Bytes: buf - }, - Attributes: ['AGE_RANGE', 'GENDER'] - } - try { - const result = await rek.detectFaces(params).promise() - console.log({ result }) - return result - } catch (e) { - console.log(e) - } -} diff --git a/src/server/goodid/aws.js b/src/server/goodid/aws.js new file mode 100644 index 00000000..127433a2 --- /dev/null +++ b/src/server/goodid/aws.js @@ -0,0 +1,31 @@ +// @flow + +import REK from 'aws-sdk/clients/rekognition' +import { once } from 'lodash' + +import conf from '../server.config' + +export const getRecognitionClient = once(() => { + const { awsSesAccessKey, awsSesSecretAccessKey, awsSesRegion } = conf + + if (!awsSesAccessKey || !awsSesRegion || !awsSesSecretAccessKey) { + throw new Error('Missing AWS configuration') + } + + return new REK({ + region: awsSesRegion, + accessKeyId: awsSesAccessKey, + secretAccessKey: awsSesSecretAccessKey + }) +}) + +export const detectFaces = async imageBase64 => { + const payload = { + Attributes: ['AGE_RANGE', 'GENDER'], + Image: { + Bytes: Buffer.from(imageBase64, 'base64') + } + } + + return getRecognitionClient().detectFaces(payload).promise() +} From 2c8abea72b34916f90ddc8ba7b0ab385d5087434 Mon Sep 17 00:00:00 2001 From: John Smith Date: Tue, 12 Mar 2024 01:56:11 +0200 Subject: [PATCH 03/12] small refactoring to exclude code repetition and re-distribute utils with corresponding modules --- src/server/goodid/goodid-middleware.js | 40 +++++++ .../processor/EnrollmentProcessor.js | 33 +++++- src/server/verification/verificationAPI.js | 105 +++++------------- 3 files changed, 97 insertions(+), 81 deletions(-) diff --git a/src/server/goodid/goodid-middleware.js b/src/server/goodid/goodid-middleware.js index cc2620c3..4092b7fa 100644 --- a/src/server/goodid/goodid-middleware.js +++ b/src/server/goodid/goodid-middleware.js @@ -163,3 +163,43 @@ export default function addGoodIDMiddleware(app: Router, utils) { }) ) } + +/* + +app.post( + '/verify/agegender', + passport.authenticate('jwt', { session: false }), + requestRateLimiter(1, 1), + wrapAsync(async (req, res) => { + const { user, log } = req + let { v1Identifier, v2Identifier } = req.body + const { gdAddress } = user + + const zoomProvider = getZoomProvider() + + // for v2 identifier - verify that identifier is for the address we are going to whitelist + await verifyFVIdentifier(v2Identifier, gdAddress) + + // TODO: processor & normalize + v2Identifier = v2Identifier.slice(0, 42) + v1Identifier = v1Identifier.replace('0x', '') // wallet will also supply the v1 identifier as fvSigner, we remove '0x' for public address + + // here we check if wallet was registered using v1 of v2 identifier + const [recordV2, recordV1] = await Promise.all([ + zoomProvider.getEnrollment(v2Identifier, log), + v1Identifier && zoomProvider.getEnrollment(v1Identifier, log) + ]) + + const record = recordV2 || recordV1 + if (!record) throw new Error('face record not found') + const { auditTrailBase64 } = record + const { FaceDetails } = await detectFaces(auditTrailBase64) + log.info({ FaceDetails }) + await Promise.all([ + // semaphore.enrollAge(FaceDetails[0].AgeRange), + // semaphore.enrollGender(FaceDetails[0].Gender.Value) + ]) + + res.json({ ok: 1 }) + }) +)*/ diff --git a/src/server/verification/processor/EnrollmentProcessor.js b/src/server/verification/processor/EnrollmentProcessor.js index cc2c7fc9..eee32708 100644 --- a/src/server/verification/processor/EnrollmentProcessor.js +++ b/src/server/verification/processor/EnrollmentProcessor.js @@ -1,6 +1,7 @@ // @flow import { chunk, noop } from 'lodash' import moment from 'moment' +import { toChecksumAddress } from 'web3-utils' import Config from '../../server.config' import { default as AdminWallet } from '../../blockchain/MultiWallet' @@ -14,6 +15,10 @@ import EnrollmentSession from './EnrollmentSession' import getZoomProvider from './provider/ZoomProvider' import { DisposeAt, scheduleDisposalTask, DISPOSE_ENROLLMENTS_TASK, forEnrollment } from '../cron/taskUtil' +import { recoverPublickey } from '../../utils/eth' +import { FV_IDENTIFIER_MSG2 } from '../../login/login-middleware' +import { strcasecmp } from '../../utils/string' + // count of chunks pending tasks should (approximately) be split to const DISPOSE_BATCH_AMOUNT = 10 // minimal & maximal chunk sizes @@ -140,6 +145,30 @@ class EnrollmentProcessor { } } + normalizeIdentifiers(enrollmentIdentifier, v1EnrollmentIdentifier = null) { + return { + identifier: enrollmentIdentifier.slice(0, 42), + v1Identifier: v1EnrollmentIdentifier ? v1EnrollmentIdentifier.replace('0x', '') : null + } + } + + async verifyIdentifier(enrollmentIdentifier, gdAddress) { + // check v2, v2 identifier is expected to be the whole signature + if (enrollmentIdentifier.length < 42) { + return + } + + const signer = recoverPublickey( + enrollmentIdentifier, + FV_IDENTIFIER_MSG2({ account: toChecksumAddress(gdAddress) }), + '' + ) + + if (!strcasecmp(signer, gdAddress)) { + throw new Error(`identifier signer doesn't match user ${signer} != ${gdAddress}`) + } + } + async isIdentifierExists(enrollmentIdentifier: string) { return this.provider.isEnrollmentExists(enrollmentIdentifier) } @@ -191,9 +220,7 @@ class EnrollmentProcessor { if (keepEnrollments > 0) { deletedAccountFilters.createdAt = { - $lte: moment() - .subtract(keepEnrollments, 'hours') - .toDate() + $lte: moment().subtract(keepEnrollments, 'hours').toDate() } } diff --git a/src/server/verification/verificationAPI.js b/src/server/verification/verificationAPI.js index f8fceb8e..4478dab1 100644 --- a/src/server/verification/verificationAPI.js +++ b/src/server/verification/verificationAPI.js @@ -3,7 +3,7 @@ import { Router } from 'express' import passport from 'passport' import { get, defaults, memoize, omit } from 'lodash' -import { sha3, toChecksumAddress, keccak256 } from 'web3-utils' +import { sha3, keccak256 } from 'web3-utils' import web3Abi from 'web3-eth-abi' import requestIp from 'request-ip' import type { LoggedUser, StorageAPI, UserRecord, VerificationAPI } from '../../imports/types' @@ -15,28 +15,14 @@ import OTP from '../../imports/otp' import conf from '../server.config' import OnGage from '../crm/ongage' import { sendTemplateEmail } from '../aws-ses/aws-ses' -import { detectFaces } from '../aws-rekognition/aws-rekognition' import fetch from 'cross-fetch' import createEnrollmentProcessor from './processor/EnrollmentProcessor.js' import createIdScanProcessor from './processor/IdScanProcessor' import { cancelDisposalTask } from './cron/taskUtil' -import { recoverPublickey } from '../utils/eth' import { shouldLogVerificaitonError } from './utils/logger' import { syncUserEmail } from '../storage/addUserSteps' -import { FV_IDENTIFIER_MSG2 } from '../login/login-middleware' -import getZoomProvider from './processor/provider/ZoomProvider' - -const verifyFVIdentifier = async (identifier, gdAddress) => { - //check v2, v2 identifier is expected to be the whole signature - if (identifier.length >= 42) { - const signer = recoverPublickey(identifier, FV_IDENTIFIER_MSG2({ account: toChecksumAddress(gdAddress) }), '') - - if (signer.toLowerCase() !== gdAddress.toLowerCase()) { - throw new Error(`identifier signer doesn't match user ${signer} != ${gdAddress}`) - } - } -} +import { recoverPublickey } from '../utils/eth' // try to cache responses from faucet abuse to prevent 500 errors from server // if same user keep requesting. @@ -71,20 +57,19 @@ const setup = (app: Router, verifier: VerificationAPI, storage: StorageAPI) => { const processor = createEnrollmentProcessor(storage, log) // for v2 identifier - verify that identifier is for the address we are going to whitelist - await verifyFVIdentifier(enrollmentIdentifier, gdAddress) + await processor.verifyIdentifier(enrollmentIdentifier, gdAddress) - let v2Identifier = enrollmentIdentifier.slice(0, 42) - let v1Identifier = fvSigner && fvSigner.replace('0x', '') // wallet will also supply the v1 identifier as fvSigner, we remove '0x' for public address + const { identifier, v1Identifier } = processor.normalizeIdentifiers(enrollmentIdentifier, fvSigner) // here we check if wallet was registered using v1 of v2 identifier const [isV2, isV1] = await Promise.all([ - processor.isIdentifierExists(v2Identifier), + processor.isIdentifierExists(identifier), v1Identifier && processor.isIdentifierExists(v1Identifier) ]) if (isV2) { //in v2 we expect the enrollmentidentifier to be the whole signature, so we cut it down to 42 - await processor.enqueueDisposal(user, v2Identifier, log) + await processor.enqueueDisposal(user, identifier, log) } if (isV1) { @@ -121,12 +106,11 @@ const setup = (app: Router, verifier: VerificationAPI, storage: StorageAPI) => { log.debug('check face status request:', { fvSigner, enrollmentIdentifier, user }) try { - let v2Identifier = enrollmentIdentifier.slice(0, 42) - let v1Identifier = fvSigner && fvSigner.replace('0x', '') // wallet also provide older identifier in case it was created before v2 - const processor = createEnrollmentProcessor(storage, log) + const { identifier, v1Identifier } = processor.normalizeIdentifiers(enrollmentIdentifier, fvSigner) + const [isDisposingV2, isDisposingV1] = await Promise.all([ - processor.isEnqueuedForDisposal(v2Identifier, log), + processor.isEnqueuedForDisposal(identifier, log), v1Identifier && processor.isEnqueuedForDisposal(v1Identifier, log) ]) @@ -234,12 +218,11 @@ const setup = (app: Router, verifier: VerificationAPI, storage: StorageAPI) => { try { // for v2 identifier - verify that identifier is for the address we are going to whitelist // for v1 this will do nothing - await verifyFVIdentifier(enrollmentIdentifier, gdAddress) - - let v2Identifier = enrollmentIdentifier.slice(0, 42) - let v1Identifier = fvSigner && fvSigner.replace('0x', '') // wallet will also supply the v1 identifier as fvSigner, we remove '0x' for public address const enrollmentProcessor = createEnrollmentProcessor(storage, log) + const { identifier, v1Identifier } = enrollmentProcessor.normalizeIdentifiers(enrollmentIdentifier, fvSigner) + + await enrollmentProcessor.verifyIdentifier(enrollmentIdentifier, gdAddress) // here we check if wallet was registered using v1 of v2 identifier const isV1 = !!v1Identifier && (await enrollmentProcessor.isIdentifierExists(v1Identifier)) @@ -249,15 +232,15 @@ const setup = (app: Router, verifier: VerificationAPI, storage: StorageAPI) => { // delete previous enrollment. // once user completes FV it will create a new record under his V2 id. update his lastAuthenticated. and enqueue for disposal if (isV1) { - log.info('v1 identifier found, converting to v2', { v1Identifier, v2Identifier, gdAddress }) + log.info('v1 identifier found, converting to v2', { v1Identifier, v2Identifier: identifier, gdAddress }) await Promise.all([ enrollmentProcessor.dispose(v1Identifier, log), cancelDisposalTask(storage, v1Identifier) ]) } - await enrollmentProcessor.validate(user, v2Identifier, payload) + await enrollmentProcessor.validate(user, identifier, payload) const wasWhitelisted = await AdminWallet.lastAuthenticated(gdAddress) - const enrollmentResult = await enrollmentProcessor.enroll(user, v2Identifier, payload, log) + const enrollmentResult = await enrollmentProcessor.enroll(user, identifier, payload, log) // log warn if user was whitelisted but unable to pass FV again if (wasWhitelisted > 0 && enrollmentResult.success === false) { @@ -265,7 +248,7 @@ const setup = (app: Router, verifier: VerificationAPI, storage: StorageAPI) => { wasWhitelisted, enrollmentResult, gdAddress, - v2Identifier + v2Identifier: identifier }) if (isV1) { //throw error so we de-whitelist user @@ -276,7 +259,7 @@ const setup = (app: Router, verifier: VerificationAPI, storage: StorageAPI) => { wasWhitelisted, enrollmentResult, gdAddress, - v2Identifier + v2Identifier: identifier }) } res.json(enrollmentResult) @@ -284,7 +267,8 @@ const setup = (app: Router, verifier: VerificationAPI, storage: StorageAPI) => { if (isV1) { // if we deleted the user record but had an error in whitelisting, then we must revoke his whitelisted status // since we might not have his record enrolled - const isIndexed = await enrollmentProcessor.isIdentifierIndexed(v2Identifier) + const isIndexed = await enrollmentProcessor.isIdentifierIndexed(identifier) + // if new identifier is indexed then dont revoke if (!isIndexed) { const isWhitelisted = await AdminWallet.isVerified(gdAddress) @@ -338,19 +322,21 @@ const setup = (app: Router, verifier: VerificationAPI, storage: StorageAPI) => { } try { - // for v2 identifier - verify that identifier is for the address we are going to whitelist - // for v1 this will do nothing - await verifyFVIdentifier(enrollmentIdentifier, gdAddress) + const enrollmentProcessor = createEnrollmentProcessor(storage, log) + const idscanProcessor = createIdScanProcessor(storage, log) - let v2Identifier = enrollmentIdentifier.slice(0, 42) + const { identifier } = enrollmentProcessor.normalizeIdentifiers(enrollmentIdentifier) - const idscanProcessor = createIdScanProcessor(storage, log) + await enrollmentProcessor.verifyIdentifier(enrollmentIdentifier, gdAddress) + + let { isMatch, scanResultBlob, ...scanResult } = await idscanProcessor.verify(user, identifier, payload) - let { isMatch, scanResultBlob, ...scanResult } = await idscanProcessor.verify(user, v2Identifier, payload) scanResult = omit(scanResult, ['externalDatabaseRefID', 'ocrResults', 'serverInfo', 'callData']) //remove unrequired fields log.debug('idscan results:', { isMatch, scanResult }) + const toSign = { success: true, isMatch, gdAddress, scanResult, timestamp: Date.now() } const { sig: signature } = await AdminWallet.signMessage(JSON.stringify(toSign)) + res.json({ scanResult: { ...toSign, signature }, scanResultBlob }) } catch (exception) { const { message } = exception @@ -980,43 +966,6 @@ const setup = (app: Router, verifier: VerificationAPI, storage: StorageAPI) => { } }) ) - - app.post( - '/verify/agegender', - passport.authenticate('jwt', { session: false }), - requestRateLimiter(1, 1), - wrapAsync(async (req, res) => { - const { user, log } = req - let { v1Identifier, v2Identifier } = req.body - const { gdAddress } = user - - const zoomProvider = getZoomProvider() - - // for v2 identifier - verify that identifier is for the address we are going to whitelist - await verifyFVIdentifier(v2Identifier, gdAddress) - - v2Identifier = v2Identifier.slice(0, 42) - v1Identifier = v1Identifier.replace('0x', '') // wallet will also supply the v1 identifier as fvSigner, we remove '0x' for public address - - // here we check if wallet was registered using v1 of v2 identifier - const [recordV2, recordV1] = await Promise.all([ - zoomProvider.getEnrollment(v2Identifier, log), - v1Identifier && zoomProvider.getEnrollment(v1Identifier, log) - ]) - - const record = recordV2 || recordV1 - if (!record) throw new Error('face record not found') - const { auditTrailBase64 } = record - const { FaceDetails } = await detectFaces(auditTrailBase64) - log.info({ FaceDetails }) - await Promise.all([ - // semaphore.enrollAge(FaceDetails[0].AgeRange), - // semaphore.enrollGender(FaceDetails[0].Gender.Value) - ]) - - res.json({ ok: 1 }) - }) - ) } export default setup From c81ece72972215c64420cfec346fde1afe363c6f Mon Sep 17 00:00:00 2001 From: John Smith Date: Tue, 12 Mar 2024 02:32:24 +0200 Subject: [PATCH 04/12] add checkExistence util --- src/server/goodid/goodid-middleware.js | 2 +- src/server/server-middlewares.js | 2 +- .../processor/EnrollmentProcessor.js | 9 +++++++++ src/server/verification/verificationAPI.js | 17 +++++++---------- 4 files changed, 18 insertions(+), 12 deletions(-) diff --git a/src/server/goodid/goodid-middleware.js b/src/server/goodid/goodid-middleware.js index 4092b7fa..34b18097 100644 --- a/src/server/goodid/goodid-middleware.js +++ b/src/server/goodid/goodid-middleware.js @@ -10,7 +10,7 @@ import requestRateLimiter from '../utils/requestRateLimiter' import { get } from 'lodash' import { Credential } from './veramo' -export default function addGoodIDMiddleware(app: Router, utils) { +export default function addGoodIDMiddleware(app: Router, utils, storage) { // eslint-disable-line /** * POST /goodid/certificate/location * Content-Type: application/json diff --git a/src/server/server-middlewares.js b/src/server/server-middlewares.js index e17ed4c8..c54df3d0 100644 --- a/src/server/server-middlewares.js +++ b/src/server/server-middlewares.js @@ -60,7 +60,7 @@ export default async (app: Router) => { addStorageMiddlewares(app, UserDBPrivate) addVerificationMiddlewares(app, VerificationAPI, UserDBPrivate) - addGoodIDMiddleware(app, GoodIDUtils) + addGoodIDMiddleware(app, GoodIDUtils, UserDBPrivate) app.get( '/strings', diff --git a/src/server/verification/processor/EnrollmentProcessor.js b/src/server/verification/processor/EnrollmentProcessor.js index eee32708..fcc26731 100644 --- a/src/server/verification/processor/EnrollmentProcessor.js +++ b/src/server/verification/processor/EnrollmentProcessor.js @@ -145,6 +145,15 @@ class EnrollmentProcessor { } } + async checkExistence(enrollmentIdentifier, v1EnrollmentIdentifier) { + const [exists, v1Exists] = await Promise.all([ + this.isIdentifierExists(enrollmentIdentifier), + v1EnrollmentIdentifier && this.isIdentifierExists(v1EnrollmentIdentifier) + ]) + + return { exists, v1Exists } + } + normalizeIdentifiers(enrollmentIdentifier, v1EnrollmentIdentifier = null) { return { identifier: enrollmentIdentifier.slice(0, 42), diff --git a/src/server/verification/verificationAPI.js b/src/server/verification/verificationAPI.js index 4478dab1..5bef25dc 100644 --- a/src/server/verification/verificationAPI.js +++ b/src/server/verification/verificationAPI.js @@ -62,17 +62,14 @@ const setup = (app: Router, verifier: VerificationAPI, storage: StorageAPI) => { const { identifier, v1Identifier } = processor.normalizeIdentifiers(enrollmentIdentifier, fvSigner) // here we check if wallet was registered using v1 of v2 identifier - const [isV2, isV1] = await Promise.all([ - processor.isIdentifierExists(identifier), - v1Identifier && processor.isIdentifierExists(v1Identifier) - ]) + const { exists, v1Exists } = await processor.checkExistence(identifier, v1Identifier) - if (isV2) { + if (exists) { //in v2 we expect the enrollmentidentifier to be the whole signature, so we cut it down to 42 await processor.enqueueDisposal(user, identifier, log) } - if (isV1) { + if (v1Exists) { await processor.enqueueDisposal(user, v1Identifier, log) } } catch (exception) { @@ -225,13 +222,13 @@ const setup = (app: Router, verifier: VerificationAPI, storage: StorageAPI) => { await enrollmentProcessor.verifyIdentifier(enrollmentIdentifier, gdAddress) // here we check if wallet was registered using v1 of v2 identifier - const isV1 = !!v1Identifier && (await enrollmentProcessor.isIdentifierExists(v1Identifier)) + const { v1Exists } = await enrollmentProcessor.checkExistence(identifier, v1Identifier) try { // if v1, we convert to v2 // delete previous enrollment. // once user completes FV it will create a new record under his V2 id. update his lastAuthenticated. and enqueue for disposal - if (isV1) { + if (v1Exists) { log.info('v1 identifier found, converting to v2', { v1Identifier, v2Identifier: identifier, gdAddress }) await Promise.all([ enrollmentProcessor.dispose(v1Identifier, log), @@ -250,7 +247,7 @@ const setup = (app: Router, verifier: VerificationAPI, storage: StorageAPI) => { gdAddress, v2Identifier: identifier }) - if (isV1) { + if (v1Exists) { //throw error so we de-whitelist user throw new Error('User failed to re-authenticate with V1 identifier') } @@ -264,7 +261,7 @@ const setup = (app: Router, verifier: VerificationAPI, storage: StorageAPI) => { } res.json(enrollmentResult) } catch (e) { - if (isV1) { + if (v1Exists) { // if we deleted the user record but had an error in whitelisting, then we must revoke his whitelisted status // since we might not have his record enrolled const isIndexed = await enrollmentProcessor.isIdentifierIndexed(identifier) From f748bfd67fc04ab154b74f8a2d0cedeadfe33bfc Mon Sep 17 00:00:00 2001 From: John Smith Date: Tue, 12 Mar 2024 03:17:52 +0200 Subject: [PATCH 05/12] add endpoint, aws age check --- src/server/goodid/goodid-middleware.js | 68 ++++++++++++++++++- src/server/goodid/utils.js | 10 +++ .../processor/EnrollmentProcessor.js | 11 ++- 3 files changed, 86 insertions(+), 3 deletions(-) diff --git a/src/server/goodid/goodid-middleware.js b/src/server/goodid/goodid-middleware.js index 34b18097..e8b19523 100644 --- a/src/server/goodid/goodid-middleware.js +++ b/src/server/goodid/goodid-middleware.js @@ -9,8 +9,10 @@ import { wrapAsync } from '../utils/helpers' import requestRateLimiter from '../utils/requestRateLimiter' import { get } from 'lodash' import { Credential } from './veramo' +import createEnrollmentProcessor from '../verification/processor/EnrollmentProcessor' +import { enrollmentNotFoundMessage } from '../verification/utils/constants' -export default function addGoodIDMiddleware(app: Router, utils, storage) { // eslint-disable-line +export default function addGoodIDMiddleware(app: Router, utils, storage) { /** * POST /goodid/certificate/location * Content-Type: application/json @@ -110,6 +112,70 @@ export default function addGoodIDMiddleware(app: Router, utils, storage) { // es }) ) + /** + * POST /goodid/certificate/identity + * Content-Type: application/json + * { + * "enrollmentIdentifier": "", + * "fvSigner": "", // optional + * "fvAgeCheck": true|false // optional + * } + */ + app.post( + '/goodid/certificate/identity', + requestRateLimiter(10, 1), + passport.authenticate('jwt', { session: false }), + wrapAsync(async (req, res) => { + const { user, body, log } = req + const { enrollmentIdentifier, fvSigner = '', fvAgeCheck = false } = body + const { gdAddress } = user + + const enrollmentProcessor = createEnrollmentProcessor(storage, log) + + try { + await enrollmentProcessor.verifyIdentifier(enrollmentIdentifier, gdAddress) + + const { identifier, v1Identifier } = enrollmentProcessor.normalizeIdentifiers(enrollmentIdentifier, fvSigner) + const { exists, v1Exists } = await enrollmentProcessor.checkExistence(identifier, v1Identifier) + + const faceIdentifier = exists ? identifier : v1Exists ? v1Identifier : null + + if (!faceIdentifier) { + throw new Error(enrollmentNotFoundMessage) + } + + const { auditTrailBase64 } = await enrollmentProcessor.getEnrollment(faceIdentifier, log) + const ageGenderEstimate = await utils.ageGenderCheck(auditTrailBase64) + let ageEstimateFacetec = {} + + if (fvAgeCheck) { + // TODO: age check FaceTec, override aws value + } + + const subject = { + unique: true, + ...ageGenderEstimate, + ...ageEstimateFacetec + } + + const credentials = [Credential.Identity, Credential.Gender, Credential.Age] + + const ceriticate = await utils.issueCertificate(gdAddress, credentials, subject) + + res.json({ success: true, ceriticate }) + } catch (exception) { + const { message } = exception + + log.error('Failed to issue identity ceritifate:', message, exception, { + enrollmentIdentifier, + fvSigner, + fvAgeCheck + }) + res.status(400).json({ success: false, error: message }) + } + }) + ) + /** * POST /goodid/certificate/verify * Content-Type: application/json diff --git a/src/server/goodid/utils.js b/src/server/goodid/utils.js index 13449ae5..28246fc8 100644 --- a/src/server/goodid/utils.js +++ b/src/server/goodid/utils.js @@ -4,6 +4,7 @@ import { PhoneNumberUtil } from 'google-libphonenumber' import { substituteParams } from '../utils/axios' import { flatten, get, toUpper } from 'lodash' import { getAgent, getSubjectId } from './veramo' +import { detectFaces } from './aws' export class GoodIDUtils { constructor(httpApi, phoneNumberApi, getVeramoAgent) { @@ -62,6 +63,15 @@ export class GoodIDUtils { return phoneUtil.getRegionCodeForNumber(number) } + async ageGenderCheck(imageBase64) { + const { FaceDetails } = await detectFaces(imageBase64) + const [{ AgeRange, Gender }] = FaceDetails + const { Value: gender } = Gender + const { Low: from, High: to } = AgeRange + + return { gender, age: { from, to } } + } + async issueCertificate(gdAddress, credentials, payload = {}) { const agent = await this.getVeramoAgent() const identifier = await agent.didManagerGetByAlias({ alias: 'default' }) diff --git a/src/server/verification/processor/EnrollmentProcessor.js b/src/server/verification/processor/EnrollmentProcessor.js index fcc26731..b54d7201 100644 --- a/src/server/verification/processor/EnrollmentProcessor.js +++ b/src/server/verification/processor/EnrollmentProcessor.js @@ -178,6 +178,13 @@ class EnrollmentProcessor { } } + async getEnrollment(enrollmentIdentifier: string, customLogger = null): Promise { + const { provider, logger } = this + const log = customLogger || logger + + return provider.getEnrollment(enrollmentIdentifier, log) + } + async isIdentifierExists(enrollmentIdentifier: string) { return this.provider.isEnrollmentExists(enrollmentIdentifier) } @@ -328,8 +335,8 @@ const enrollmentProcessors = new WeakMap() export default (storage, log) => { if (!enrollmentProcessors.has(storage)) { - log = log || logger.child({ from: 'EnrollmentProcessor' }) - const enrollmentProcessor = new EnrollmentProcessor(Config, storage, AdminWallet, log) + const processorLogger = log || logger.child({ from: 'EnrollmentProcessor' }) + const enrollmentProcessor = new EnrollmentProcessor(Config, storage, AdminWallet, processorLogger) enrollmentProcessor.registerProvier(getZoomProvider()) enrollmentProcessors.set(storage, enrollmentProcessor) From 72467b768b433ba91a41d9b37b5c5b5f7f4c055f Mon Sep 17 00:00:00 2001 From: John Smith Date: Tue, 12 Mar 2024 18:24:23 +0200 Subject: [PATCH 06/12] add fv age check --- src/server/goodid/goodid-middleware.js | 28 +++++++-------- src/server/verification/api/ZoomAPI.js | 34 ++++++++++++++----- .../processor/EnrollmentProcessor.js | 7 ++++ .../processor/provider/ZoomProvider.js | 23 ++++++++++++- src/server/verification/utils/constants.js | 11 ++++++ 5 files changed, 78 insertions(+), 25 deletions(-) diff --git a/src/server/goodid/goodid-middleware.js b/src/server/goodid/goodid-middleware.js index e8b19523..9f2cbf1a 100644 --- a/src/server/goodid/goodid-middleware.js +++ b/src/server/goodid/goodid-middleware.js @@ -12,6 +12,8 @@ import { Credential } from './veramo' import createEnrollmentProcessor from '../verification/processor/EnrollmentProcessor' import { enrollmentNotFoundMessage } from '../verification/utils/constants' +const { Location, Gender, Age, Identity } = Credential + export default function addGoodIDMiddleware(app: Router, utils, storage) { /** * POST /goodid/certificate/location @@ -69,7 +71,7 @@ export default function addGoodIDMiddleware(app: Router, utils, storage) { const { longitude, latitude } = get(body, 'geoposition.coords', {}) const issueCertificate = async countryCode => { - const ceriticate = await utils.issueCertificate(gdAddress, Credential.Location, { countryCode }) + const ceriticate = await utils.issueCertificate(gdAddress, Location, { countryCode }) res.json({ success: true, ceriticate }) } @@ -118,7 +120,7 @@ export default function addGoodIDMiddleware(app: Router, utils, storage) { * { * "enrollmentIdentifier": "", * "fvSigner": "", // optional - * "fvAgeCheck": true|false // optional + * "fvAgeCheck": "", // optional * } */ app.post( @@ -127,7 +129,7 @@ export default function addGoodIDMiddleware(app: Router, utils, storage) { passport.authenticate('jwt', { session: false }), wrapAsync(async (req, res) => { const { user, body, log } = req - const { enrollmentIdentifier, fvSigner = '', fvAgeCheck = false } = body + const { enrollmentIdentifier, fvSigner, fvAgeCheck } = body const { gdAddress } = user const enrollmentProcessor = createEnrollmentProcessor(storage, log) @@ -145,22 +147,17 @@ export default function addGoodIDMiddleware(app: Router, utils, storage) { } const { auditTrailBase64 } = await enrollmentProcessor.getEnrollment(faceIdentifier, log) - const ageGenderEstimate = await utils.ageGenderCheck(auditTrailBase64) - let ageEstimateFacetec = {} + const estimation = await utils.ageGenderCheck(auditTrailBase64) - if (fvAgeCheck) { - // TODO: age check FaceTec, override aws value + if ((fvAgeCheck || 'none') !== 'none') { + // strict or approximate + estimation.age = await enrollmentProcessor.estimateAge(faceIdentifier, fvAgeCheck === 'strict', log) } - const subject = { + const ceriticate = await utils.issueCertificate(gdAddress, [Identity, Gender, Age], { unique: true, - ...ageGenderEstimate, - ...ageEstimateFacetec - } - - const credentials = [Credential.Identity, Credential.Gender, Credential.Age] - - const ceriticate = await utils.issueCertificate(gdAddress, credentials, subject) + ...estimation + }) res.json({ success: true, ceriticate }) } catch (exception) { @@ -171,6 +168,7 @@ export default function addGoodIDMiddleware(app: Router, utils, storage) { fvSigner, fvAgeCheck }) + res.status(400).json({ success: false, error: message }) } }) diff --git a/src/server/verification/api/ZoomAPI.js b/src/server/verification/api/ZoomAPI.js index 1a2482dc..512cccfa 100644 --- a/src/server/verification/api/ZoomAPI.js +++ b/src/server/verification/api/ZoomAPI.js @@ -233,6 +233,19 @@ export class ZoomAPI { return httpClientOptions } + async estimateAge(enrollmentIdentifier, customLogger = null) { + const payload = { + externalDatabaseRefID: enrollmentIdentifier + } + + try { + return await this.http.post(`/estimate-age-3d-v2`, payload, { customLogger }) + } catch (exception) { + this._proceedEnrollmentNotFoundError(exception) + throw exception + } + } + _configureRequests() { const { request } = this.http.interceptors @@ -452,15 +465,7 @@ export class ZoomAPI { try { response = await this.http.post(`/3d-db/${operation}`, payload, { customLogger }) } catch (exception) { - const { message } = exception - - if (/enrollment\s+does\s+not\s+exist/i.test(message)) { - assign(exception, { - message: enrollmentNotFoundMessage, - name: ZoomAPIError.FacemapNotFound - }) - } - + this._proceedEnrollmentNotFoundError(exception) throw exception } @@ -488,6 +493,17 @@ export class ZoomAPI { return response } + _proceedEnrollmentNotFoundError(exception) { + const { message } = exception + + if (/enrollment\s+does\s+not\s+exist/i.test(message)) { + assign(exception, { + message: enrollmentNotFoundMessage, + name: ZoomAPIError.FacemapNotFound + }) + } + } + _createLoggingSafeCopy(payload) { if (isArray(payload)) { return payload.map(item => this._createLoggingSafeCopy(item)) diff --git a/src/server/verification/processor/EnrollmentProcessor.js b/src/server/verification/processor/EnrollmentProcessor.js index b54d7201..a21ef920 100644 --- a/src/server/verification/processor/EnrollmentProcessor.js +++ b/src/server/verification/processor/EnrollmentProcessor.js @@ -223,6 +223,13 @@ class EnrollmentProcessor { await provider.dispose(enrollmentIdentifier, customLogger) } + async estimateAge(enrollmentIdentifier, strict = false, customLogger = null) { + const { provider, logger } = this + const log = customLogger || logger + + return provider.estimateAge(enrollmentIdentifier, strict, log) + } + async disposeEnqueuedEnrollments( onProcessed: (identifier: string, exception?: Error) => void = noop, customLogger = null diff --git a/src/server/verification/processor/provider/ZoomProvider.js b/src/server/verification/processor/provider/ZoomProvider.js index fdfa7b95..7aa182a3 100644 --- a/src/server/verification/processor/provider/ZoomProvider.js +++ b/src/server/verification/processor/provider/ZoomProvider.js @@ -8,7 +8,8 @@ import { duplicateFoundMessage, successfullyEnrolledMessage, alreadyEnrolledMessage, - ZoomLicenseType + ZoomLicenseType, + AgeV2GroupEnum } from '../../utils/constants' import { faceSnapshotFields } from '../../utils/logger' @@ -293,6 +294,26 @@ class ZoomProvider implements IEnrollmentProvider { } } + async estimateAge(enrollmentIdentifier, strict = false, customLogger = null) { + const { api, logger } = this + const log = customLogger || logger + const { success, ageV2GroupEnumInt } = await api.estimateAge(enrollmentIdentifier, log) + + if (!ageV2GroupEnumInt) { + throw new Error('Age estimation fails to run') + } + + if (!success) { + if (strict) { + throw new Error('Age check confidence too low') + } + + log.warn('Confidence <99.5%', { ageV2GroupEnumInt }) + } + + return AgeV2GroupEnum[ageV2GroupEnumInt] + } + async _enrollmentOperation(logLabel, enrollmentIdentifier, customLogger = null, operation): Promise { const log = customLogger || this.logger diff --git a/src/server/verification/utils/constants.js b/src/server/verification/utils/constants.js index 7bf2aa18..52e431b1 100644 --- a/src/server/verification/utils/constants.js +++ b/src/server/verification/utils/constants.js @@ -13,6 +13,17 @@ export const ZoomLicenseType = { Mobile: 'native' } +export const AgeV2GroupEnum = [, // eslint-disable-line + { to: 7 }, + { from: 8, to: 12 }, + { from: 13, to: 15 }, + { from: 16, to: 17 }, + { from: 18, to: 20 }, + { from: 21, to: 24 }, + { from: 25, to: 29 }, + { from: 30 } +] + export const failedEnrollmentMessage = 'FaceMap could not be enrolled' export const failedLivenessMessage = 'Liveness could not be determined' export const failedMatchMessage = 'FaceMap could not be 3D-matched and updated' From 238d444f6fb145ab129568c7abc136030680be48 Mon Sep 17 00:00:00 2001 From: John Smith Date: Tue, 12 Mar 2024 18:34:20 +0200 Subject: [PATCH 07/12] update docs --- src/server/goodid/goodid-middleware.js | 28 ++++++++++++++++++++++++++ 1 file changed, 28 insertions(+) diff --git a/src/server/goodid/goodid-middleware.js b/src/server/goodid/goodid-middleware.js index 9f2cbf1a..5e8f2dd3 100644 --- a/src/server/goodid/goodid-middleware.js +++ b/src/server/goodid/goodid-middleware.js @@ -122,6 +122,34 @@ export default function addGoodIDMiddleware(app: Router, utils, storage) { * "fvSigner": "", // optional * "fvAgeCheck": "", // optional * } + * + * HTTP/1.1 200 OK + * Content-Type: application/json + * { + * "success": true, + * "certificate": { + * "credential": { + * "credentialSubject": { + * "id": 'did:ethr:', + * "gender": "" // yep, AWS doesn't supports LGBT, + * "age": { + * "from": , // "open" ranges also allowed, e.g. { to: 7 } or { from: 30 } + * "to": , // this value includes to the range, "from 30" means 30 and older, if < 30 you will get "from 25 to 29" + * } + * }, + * "issuer": { + * "id": 'did:key:', + * }, + * "type": ["VerifiableCredential", "VerifiableIdentityCredential", "VerifiableAgeCredential", "VerifiableGenderCredential"], + * "@context": ["https://www.w3.org/2018/credentials/v1"], + * "issuanceDate": "2022-10-28T11:54:22.000Z", + * "proof": { + * "type": "JwtProof2020", + * "jwt": 'eyJhbGciOiJFUzI1NksiLCJ0eXAiOiJKV1QifQ.eyJ2YyI6eyJAY29udGV4dCI6WyJodHRwczovL3d3dy53My5vcmcvMjAxOC9jcmVkZW50aWFscy92MSJdLCJ0eXBlIjpbIlZlcmlmaWFibGVDcmVkZW50aWFsIl0sImNyZWRlbnRpYWxTdWJqZWN0Ijp7InlvdSI6IlJvY2sifX0sInN1YiI6ImRpZDp3ZWI6ZXhhbXBsZS5jb20iLCJuYmYiOjE2NjY5NTgwNjIsImlzcyI6ImRpZDpldGhyOmdvZXJsaToweDAzNTBlZWVlYTE0MTBjNWIxNTJmMWE4OGUwZmZlOGJiOGEwYmMzZGY4NjhiNzQwZWIyMzUyYjFkYmY5M2I1OWMxNiJ9.EPeuQBpkK13V9wu66SLg7u8ebY2OS8b2Biah2Vw-RI-Atui2rtujQkVc2t9m1Eqm4XQFECfysgQBdWwnSDvIjw', + * }, + * }, + * } + * } */ app.post( '/goodid/certificate/identity', From 2c4a5ee3a9fc1107066059f46151930c3b413741 Mon Sep 17 00:00:00 2001 From: John Smith Date: Mon, 18 Mar 2024 16:17:35 +0200 Subject: [PATCH 08/12] revert changes --- src/server/goodid/__tests__/face.json | 1 + src/server/goodid/__tests__/goodidAPI.js | 6 ++ src/server/goodid/goodid-middleware.js | 33 +++++----- src/server/goodid/utils.js | 4 +- src/server/verification/api/ZoomAPI.js | 34 +++------- .../processor/EnrollmentProcessor.js | 45 ------------- .../processor/provider/ZoomProvider.js | 23 +------ src/server/verification/utils/constants.js | 11 ---- src/server/verification/utils/utils.js | 28 ++++++++ src/server/verification/verificationAPI.js | 64 +++++++++---------- 10 files changed, 95 insertions(+), 154 deletions(-) create mode 100644 src/server/goodid/__tests__/face.json create mode 100644 src/server/verification/utils/utils.js diff --git a/src/server/goodid/__tests__/face.json b/src/server/goodid/__tests__/face.json new file mode 100644 index 00000000..0929020f --- /dev/null +++ b/src/server/goodid/__tests__/face.json @@ -0,0 +1 @@ +{"externalDatabaseRefID":"0x5efe0a7c45d3a07ca7faf5c09c62eee8bb944e10","faceMapBase64":"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","auditTrailBase64":"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","success":true,"wasProcessed":true,"callData":{"tid":"38c11fc9-305b-4e3e-8804-cb7b6d637d09","path":"/enrollment-3d","date":"Mar 16, 2024, 12:44:36 AM","epochSecond":1710549876,"requestMethod":"GET"},"additionalSessionData":{"isAdditionalDataPartiallyIncomplete":true},"error":false,"serverInfo":{"coreServerSDKVersion":"9.6.104","customOrStandardServerSDKVersion":"9.6.104","type":"Custom","mode":"Production","notice":"You should only be reading this if you are in server-side code. Please make sure you do not allow the FaceTec Server to be called from the public internet."}} \ No newline at end of file diff --git a/src/server/goodid/__tests__/goodidAPI.js b/src/server/goodid/__tests__/goodidAPI.js index 433dc316..741509bc 100644 --- a/src/server/goodid/__tests__/goodidAPI.js +++ b/src/server/goodid/__tests__/goodidAPI.js @@ -7,6 +7,8 @@ import UserDBPrivate from '../../db/mongo/user-privat-provider' import makeServer from '../../server-test' import { getCreds, getToken } from '../../__util__' +//import testFaceMock from './face.json' + describe('goodidAPI', () => { let server let token @@ -70,6 +72,10 @@ describe('goodidAPI', () => { } } + //const testEnrollmentIdentifier = '0x5efe0a7c45d3a07ca7faf5c09c62eee8bb944e1087594b2b951e00fb29f8318912bd8b8b0d72ddf34d99ed0eeb3574237c7ba02e8b74ae6ed107b5337e8df79e1c' + + //https://goodid.gooddollar.org/?account=0xc218C7bB7F87a544EB7dCC9D776131A75E362d9C&chain=122&fvsig=0x5efe0a7c45d3a07ca7faf5c09c62eee8bb944e1087594b2b951e00fb29f8318912bd8b8b0d72ddf34d99ed0eeb3574237c7ba02e8b74ae6ed107b5337e8df79e1c&firstname=Oleksii+Serdiukov&rdu=http%3A%2F%2Flocalhost%3A3000%2Fhome%2Fgooddollar + beforeAll(async () => { jest.setTimeout(50000) server = await makeServer() diff --git a/src/server/goodid/goodid-middleware.js b/src/server/goodid/goodid-middleware.js index 5e8f2dd3..90c299e8 100644 --- a/src/server/goodid/goodid-middleware.js +++ b/src/server/goodid/goodid-middleware.js @@ -11,6 +11,7 @@ import { get } from 'lodash' import { Credential } from './veramo' import createEnrollmentProcessor from '../verification/processor/EnrollmentProcessor' import { enrollmentNotFoundMessage } from '../verification/utils/constants' +import { normalizeIdentifiers, verifyIdentifier } from '../verification/utils/utils' const { Location, Gender, Age, Identity } = Credential @@ -120,7 +121,6 @@ export default function addGoodIDMiddleware(app: Router, utils, storage) { * { * "enrollmentIdentifier": "", * "fvSigner": "", // optional - * "fvAgeCheck": "", // optional * } * * HTTP/1.1 200 OK @@ -133,8 +133,8 @@ export default function addGoodIDMiddleware(app: Router, utils, storage) { * "id": 'did:ethr:', * "gender": "" // yep, AWS doesn't supports LGBT, * "age": { - * "from": , // "open" ranges also allowed, e.g. { to: 7 } or { from: 30 } - * "to": , // this value includes to the range, "from 30" means 30 and older, if < 30 you will get "from 25 to 29" + * "min": , // "open" ranges also allowed, e.g. { to: 7 } or { from: 30 } + * "max": , // this value includes to the range, "from 30" means 30 and older, if < 30 you will get "from 25 to 29" * } * }, * "issuer": { @@ -157,31 +157,31 @@ export default function addGoodIDMiddleware(app: Router, utils, storage) { passport.authenticate('jwt', { session: false }), wrapAsync(async (req, res) => { const { user, body, log } = req - const { enrollmentIdentifier, fvSigner, fvAgeCheck } = body + const { enrollmentIdentifier, fvSigner } = body const { gdAddress } = user - const enrollmentProcessor = createEnrollmentProcessor(storage, log) + const processor = createEnrollmentProcessor(storage, log) try { - await enrollmentProcessor.verifyIdentifier(enrollmentIdentifier, gdAddress) + verifyIdentifier(enrollmentIdentifier, gdAddress) - const { identifier, v1Identifier } = enrollmentProcessor.normalizeIdentifiers(enrollmentIdentifier, fvSigner) - const { exists, v1Exists } = await enrollmentProcessor.checkExistence(identifier, v1Identifier) + const { v2Identifier, v1Identifier } = normalizeIdentifiers(enrollmentIdentifier, fvSigner) - const faceIdentifier = exists ? identifier : v1Exists ? v1Identifier : null + // here we check if wallet was registered using v1 of v2 identifier + const [isV2, isV1] = await Promise.all([ + processor.isIdentifierExists(v2Identifier), + v1Identifier && processor.isIdentifierExists(v1Identifier) + ]) + + const faceIdentifier = isV2 ? v2Identifier : isV1 ? v1Identifier : null if (!faceIdentifier) { throw new Error(enrollmentNotFoundMessage) } - const { auditTrailBase64 } = await enrollmentProcessor.getEnrollment(faceIdentifier, log) + const { auditTrailBase64 } = await processor.getEnrollment(faceIdentifier, log) const estimation = await utils.ageGenderCheck(auditTrailBase64) - if ((fvAgeCheck || 'none') !== 'none') { - // strict or approximate - estimation.age = await enrollmentProcessor.estimateAge(faceIdentifier, fvAgeCheck === 'strict', log) - } - const ceriticate = await utils.issueCertificate(gdAddress, [Identity, Gender, Age], { unique: true, ...estimation @@ -193,8 +193,7 @@ export default function addGoodIDMiddleware(app: Router, utils, storage) { log.error('Failed to issue identity ceritifate:', message, exception, { enrollmentIdentifier, - fvSigner, - fvAgeCheck + fvSigner }) res.status(400).json({ success: false, error: message }) diff --git a/src/server/goodid/utils.js b/src/server/goodid/utils.js index 28246fc8..947f0cf9 100644 --- a/src/server/goodid/utils.js +++ b/src/server/goodid/utils.js @@ -67,9 +67,9 @@ export class GoodIDUtils { const { FaceDetails } = await detectFaces(imageBase64) const [{ AgeRange, Gender }] = FaceDetails const { Value: gender } = Gender - const { Low: from, High: to } = AgeRange + const { Low: min, High: max } = AgeRange - return { gender, age: { from, to } } + return { gender, age: { min, max } } } async issueCertificate(gdAddress, credentials, payload = {}) { diff --git a/src/server/verification/api/ZoomAPI.js b/src/server/verification/api/ZoomAPI.js index 512cccfa..1a2482dc 100644 --- a/src/server/verification/api/ZoomAPI.js +++ b/src/server/verification/api/ZoomAPI.js @@ -233,19 +233,6 @@ export class ZoomAPI { return httpClientOptions } - async estimateAge(enrollmentIdentifier, customLogger = null) { - const payload = { - externalDatabaseRefID: enrollmentIdentifier - } - - try { - return await this.http.post(`/estimate-age-3d-v2`, payload, { customLogger }) - } catch (exception) { - this._proceedEnrollmentNotFoundError(exception) - throw exception - } - } - _configureRequests() { const { request } = this.http.interceptors @@ -465,7 +452,15 @@ export class ZoomAPI { try { response = await this.http.post(`/3d-db/${operation}`, payload, { customLogger }) } catch (exception) { - this._proceedEnrollmentNotFoundError(exception) + const { message } = exception + + if (/enrollment\s+does\s+not\s+exist/i.test(message)) { + assign(exception, { + message: enrollmentNotFoundMessage, + name: ZoomAPIError.FacemapNotFound + }) + } + throw exception } @@ -493,17 +488,6 @@ export class ZoomAPI { return response } - _proceedEnrollmentNotFoundError(exception) { - const { message } = exception - - if (/enrollment\s+does\s+not\s+exist/i.test(message)) { - assign(exception, { - message: enrollmentNotFoundMessage, - name: ZoomAPIError.FacemapNotFound - }) - } - } - _createLoggingSafeCopy(payload) { if (isArray(payload)) { return payload.map(item => this._createLoggingSafeCopy(item)) diff --git a/src/server/verification/processor/EnrollmentProcessor.js b/src/server/verification/processor/EnrollmentProcessor.js index a21ef920..3911e467 100644 --- a/src/server/verification/processor/EnrollmentProcessor.js +++ b/src/server/verification/processor/EnrollmentProcessor.js @@ -1,7 +1,6 @@ // @flow import { chunk, noop } from 'lodash' import moment from 'moment' -import { toChecksumAddress } from 'web3-utils' import Config from '../../server.config' import { default as AdminWallet } from '../../blockchain/MultiWallet' @@ -15,10 +14,6 @@ import EnrollmentSession from './EnrollmentSession' import getZoomProvider from './provider/ZoomProvider' import { DisposeAt, scheduleDisposalTask, DISPOSE_ENROLLMENTS_TASK, forEnrollment } from '../cron/taskUtil' -import { recoverPublickey } from '../../utils/eth' -import { FV_IDENTIFIER_MSG2 } from '../../login/login-middleware' -import { strcasecmp } from '../../utils/string' - // count of chunks pending tasks should (approximately) be split to const DISPOSE_BATCH_AMOUNT = 10 // minimal & maximal chunk sizes @@ -145,39 +140,6 @@ class EnrollmentProcessor { } } - async checkExistence(enrollmentIdentifier, v1EnrollmentIdentifier) { - const [exists, v1Exists] = await Promise.all([ - this.isIdentifierExists(enrollmentIdentifier), - v1EnrollmentIdentifier && this.isIdentifierExists(v1EnrollmentIdentifier) - ]) - - return { exists, v1Exists } - } - - normalizeIdentifiers(enrollmentIdentifier, v1EnrollmentIdentifier = null) { - return { - identifier: enrollmentIdentifier.slice(0, 42), - v1Identifier: v1EnrollmentIdentifier ? v1EnrollmentIdentifier.replace('0x', '') : null - } - } - - async verifyIdentifier(enrollmentIdentifier, gdAddress) { - // check v2, v2 identifier is expected to be the whole signature - if (enrollmentIdentifier.length < 42) { - return - } - - const signer = recoverPublickey( - enrollmentIdentifier, - FV_IDENTIFIER_MSG2({ account: toChecksumAddress(gdAddress) }), - '' - ) - - if (!strcasecmp(signer, gdAddress)) { - throw new Error(`identifier signer doesn't match user ${signer} != ${gdAddress}`) - } - } - async getEnrollment(enrollmentIdentifier: string, customLogger = null): Promise { const { provider, logger } = this const log = customLogger || logger @@ -223,13 +185,6 @@ class EnrollmentProcessor { await provider.dispose(enrollmentIdentifier, customLogger) } - async estimateAge(enrollmentIdentifier, strict = false, customLogger = null) { - const { provider, logger } = this - const log = customLogger || logger - - return provider.estimateAge(enrollmentIdentifier, strict, log) - } - async disposeEnqueuedEnrollments( onProcessed: (identifier: string, exception?: Error) => void = noop, customLogger = null diff --git a/src/server/verification/processor/provider/ZoomProvider.js b/src/server/verification/processor/provider/ZoomProvider.js index 7aa182a3..fdfa7b95 100644 --- a/src/server/verification/processor/provider/ZoomProvider.js +++ b/src/server/verification/processor/provider/ZoomProvider.js @@ -8,8 +8,7 @@ import { duplicateFoundMessage, successfullyEnrolledMessage, alreadyEnrolledMessage, - ZoomLicenseType, - AgeV2GroupEnum + ZoomLicenseType } from '../../utils/constants' import { faceSnapshotFields } from '../../utils/logger' @@ -294,26 +293,6 @@ class ZoomProvider implements IEnrollmentProvider { } } - async estimateAge(enrollmentIdentifier, strict = false, customLogger = null) { - const { api, logger } = this - const log = customLogger || logger - const { success, ageV2GroupEnumInt } = await api.estimateAge(enrollmentIdentifier, log) - - if (!ageV2GroupEnumInt) { - throw new Error('Age estimation fails to run') - } - - if (!success) { - if (strict) { - throw new Error('Age check confidence too low') - } - - log.warn('Confidence <99.5%', { ageV2GroupEnumInt }) - } - - return AgeV2GroupEnum[ageV2GroupEnumInt] - } - async _enrollmentOperation(logLabel, enrollmentIdentifier, customLogger = null, operation): Promise { const log = customLogger || this.logger diff --git a/src/server/verification/utils/constants.js b/src/server/verification/utils/constants.js index 52e431b1..7bf2aa18 100644 --- a/src/server/verification/utils/constants.js +++ b/src/server/verification/utils/constants.js @@ -13,17 +13,6 @@ export const ZoomLicenseType = { Mobile: 'native' } -export const AgeV2GroupEnum = [, // eslint-disable-line - { to: 7 }, - { from: 8, to: 12 }, - { from: 13, to: 15 }, - { from: 16, to: 17 }, - { from: 18, to: 20 }, - { from: 21, to: 24 }, - { from: 25, to: 29 }, - { from: 30 } -] - export const failedEnrollmentMessage = 'FaceMap could not be enrolled' export const failedLivenessMessage = 'Liveness could not be determined' export const failedMatchMessage = 'FaceMap could not be 3D-matched and updated' diff --git a/src/server/verification/utils/utils.js b/src/server/verification/utils/utils.js new file mode 100644 index 00000000..202cd633 --- /dev/null +++ b/src/server/verification/utils/utils.js @@ -0,0 +1,28 @@ +import { toChecksumAddress } from 'web3-utils' + +import { recoverPublickey } from '../../utils/eth' +import { strcasecmp } from '../../utils/string' +import { FV_IDENTIFIER_MSG2 } from '../../login/login-middleware' + +export const normalizeIdentifiers = (enrollmentIdentifier, fvSigner = null) => ({ + v2Identifier: enrollmentIdentifier.slice(0, 42), + v1Identifier: fvSigner ? fvSigner.replace('0x', '') : null +}) + +export const verifyIdentifier = (enrollmentIdentifier, gdAddress) => { + // check v2, v2 identifier is expected to be the whole signature + if (enrollmentIdentifier.length < 42) { + return + } + + const signer = recoverPublickey( + enrollmentIdentifier, + FV_IDENTIFIER_MSG2({ account: toChecksumAddress(gdAddress) }), + '' + ) + + if (strcasecmp(signer, gdAddress)) { + // returns 0 if equals + throw new Error(`identifier signer doesn't match user ${signer} != ${gdAddress}`) + } +} diff --git a/src/server/verification/verificationAPI.js b/src/server/verification/verificationAPI.js index 6eb3fa7f..8a3b01d4 100644 --- a/src/server/verification/verificationAPI.js +++ b/src/server/verification/verificationAPI.js @@ -20,9 +20,10 @@ import createEnrollmentProcessor from './processor/EnrollmentProcessor.js' import createIdScanProcessor from './processor/IdScanProcessor' import { cancelDisposalTask } from './cron/taskUtil' +import { recoverPublickey } from '../utils/eth' import { shouldLogVerificaitonError } from './utils/logger' import { syncUserEmail } from '../storage/addUserSteps' -import { recoverPublickey } from '../utils/eth' +import { normalizeIdentifiers, verifyIdentifier } from './utils/utils.js' // try to cache responses from faucet abuse to prevent 500 errors from server // if same user keep requesting. @@ -62,19 +63,22 @@ const setup = (app: Router, verifier: VerificationAPI, storage: StorageAPI) => { const processor = createEnrollmentProcessor(storage, log) // for v2 identifier - verify that identifier is for the address we are going to whitelist - await processor.verifyIdentifier(enrollmentIdentifier, gdAddress) + verifyIdentifier(enrollmentIdentifier, gdAddress) - const { identifier, v1Identifier } = processor.normalizeIdentifiers(enrollmentIdentifier, fvSigner) + const { v2Identifier, v1Identifier } = normalizeIdentifiers(enrollmentIdentifier, fvSigner) // here we check if wallet was registered using v1 of v2 identifier - const { exists, v1Exists } = await processor.checkExistence(identifier, v1Identifier) + const [isV2, isV1] = await Promise.all([ + processor.isIdentifierExists(v2Identifier), + v1Identifier && processor.isIdentifierExists(v1Identifier) + ]) - if (exists) { + if (isV2) { //in v2 we expect the enrollmentidentifier to be the whole signature, so we cut it down to 42 - await processor.enqueueDisposal(user, identifier, log) + await processor.enqueueDisposal(user, v2Identifier, log) } - if (v1Exists) { + if (isV1) { await processor.enqueueDisposal(user, v1Identifier, log) } } catch (exception) { @@ -108,11 +112,11 @@ const setup = (app: Router, verifier: VerificationAPI, storage: StorageAPI) => { log.debug('check face status request:', { fvSigner, enrollmentIdentifier, user }) try { - const processor = createEnrollmentProcessor(storage, log) - const { identifier, v1Identifier } = processor.normalizeIdentifiers(enrollmentIdentifier, fvSigner) + const { v2Identifier, v1Identifier } = normalizeIdentifiers(enrollmentIdentifier, fvSigner) + const processor = createEnrollmentProcessor(storage, log) const [isDisposingV2, isDisposingV1] = await Promise.all([ - processor.isEnqueuedForDisposal(identifier, log), + processor.isEnqueuedForDisposal(v2Identifier, log), v1Identifier && processor.isEnqueuedForDisposal(v1Identifier, log) ]) @@ -220,29 +224,28 @@ const setup = (app: Router, verifier: VerificationAPI, storage: StorageAPI) => { try { // for v2 identifier - verify that identifier is for the address we are going to whitelist // for v1 this will do nothing + verifyIdentifier(enrollmentIdentifier, gdAddress) + const { v2Identifier, v1Identifier } = normalizeIdentifiers(enrollmentIdentifier, fvSigner) const enrollmentProcessor = createEnrollmentProcessor(storage, log) - const { identifier, v1Identifier } = enrollmentProcessor.normalizeIdentifiers(enrollmentIdentifier, fvSigner) - - await enrollmentProcessor.verifyIdentifier(enrollmentIdentifier, gdAddress) // here we check if wallet was registered using v1 of v2 identifier - const { v1Exists } = await enrollmentProcessor.checkExistence(identifier, v1Identifier) + const isV1 = !!v1Identifier && (await enrollmentProcessor.isIdentifierExists(v1Identifier)) try { // if v1, we convert to v2 // delete previous enrollment. // once user completes FV it will create a new record under his V2 id. update his lastAuthenticated. and enqueue for disposal - if (v1Exists) { - log.info('v1 identifier found, converting to v2', { v1Identifier, v2Identifier: identifier, gdAddress }) + if (isV1) { + log.info('v1 identifier found, converting to v2', { v1Identifier, v2Identifier, gdAddress }) await Promise.all([ enrollmentProcessor.dispose(v1Identifier, log), cancelDisposalTask(storage, v1Identifier) ]) } - await enrollmentProcessor.validate(user, identifier, payload) + await enrollmentProcessor.validate(user, v2Identifier, payload) const wasWhitelisted = await AdminWallet.lastAuthenticated(gdAddress) - const enrollmentResult = await enrollmentProcessor.enroll(user, identifier, payload, log) + const enrollmentResult = await enrollmentProcessor.enroll(user, v2Identifier, payload, log) // log warn if user was whitelisted but unable to pass FV again if (wasWhitelisted > 0 && enrollmentResult.success === false) { @@ -250,9 +253,9 @@ const setup = (app: Router, verifier: VerificationAPI, storage: StorageAPI) => { wasWhitelisted, enrollmentResult, gdAddress, - v2Identifier: identifier + v2Identifier }) - if (v1Exists) { + if (isV1) { //throw error so we de-whitelist user throw new Error('User failed to re-authenticate with V1 identifier') } @@ -261,16 +264,15 @@ const setup = (app: Router, verifier: VerificationAPI, storage: StorageAPI) => { wasWhitelisted, enrollmentResult, gdAddress, - v2Identifier: identifier + v2Identifier }) } res.json(enrollmentResult) } catch (e) { - if (v1Exists) { + if (isV1) { // if we deleted the user record but had an error in whitelisting, then we must revoke his whitelisted status // since we might not have his record enrolled - const isIndexed = await enrollmentProcessor.isIdentifierIndexed(identifier) - + const isIndexed = await enrollmentProcessor.isIdentifierIndexed(v2Identifier) // if new identifier is indexed then dont revoke if (!isIndexed) { const isWhitelisted = await AdminWallet.isVerified(gdAddress) @@ -324,21 +326,19 @@ const setup = (app: Router, verifier: VerificationAPI, storage: StorageAPI) => { } try { - const enrollmentProcessor = createEnrollmentProcessor(storage, log) - const idscanProcessor = createIdScanProcessor(storage, log) - - const { identifier } = enrollmentProcessor.normalizeIdentifiers(enrollmentIdentifier) + // for v2 identifier - verify that identifier is for the address we are going to whitelist + // for v1 this will do nothing + verifyIdentifier(enrollmentIdentifier, gdAddress) - await enrollmentProcessor.verifyIdentifier(enrollmentIdentifier, gdAddress) + const { v2Identifier } = normalizeIdentifiers(enrollmentIdentifier) - let { isMatch, scanResultBlob, ...scanResult } = await idscanProcessor.verify(user, identifier, payload) + const idscanProcessor = createIdScanProcessor(storage, log) + let { isMatch, scanResultBlob, ...scanResult } = await idscanProcessor.verify(user, v2Identifier, payload) scanResult = omit(scanResult, ['externalDatabaseRefID', 'ocrResults', 'serverInfo', 'callData']) //remove unrequired fields log.debug('idscan results:', { isMatch, scanResult }) - const toSign = { success: true, isMatch, gdAddress, scanResult, timestamp: Date.now() } const { sig: signature } = await AdminWallet.signMessage(JSON.stringify(toSign)) - res.json({ scanResult: { ...toSign, signature }, scanResultBlob }) } catch (exception) { const { message } = exception From c40cc4e14dce4b43ad9ea099a2b5e5a847defe61 Mon Sep 17 00:00:00 2001 From: John Smith Date: Mon, 18 Mar 2024 18:47:09 +0200 Subject: [PATCH 09/12] add failure cases tests --- src/server/goodid/__tests__/goodidAPI.js | 76 ++++++++++++++++++++++-- src/server/goodid/goodid-middleware.js | 10 +++- src/server/verification/utils/utils.js | 2 +- 3 files changed, 79 insertions(+), 9 deletions(-) diff --git a/src/server/goodid/__tests__/goodidAPI.js b/src/server/goodid/__tests__/goodidAPI.js index 741509bc..9578e5e8 100644 --- a/src/server/goodid/__tests__/goodidAPI.js +++ b/src/server/goodid/__tests__/goodidAPI.js @@ -1,11 +1,17 @@ import { get } from 'lodash' -import request from 'supertest' import { sha3 } from 'web3-utils' -import UserDBPrivate from '../../db/mongo/user-privat-provider' +import request from 'supertest' +import MockAdapter from 'axios-mock-adapter' + +import storage from '../../db/mongo/user-privat-provider' +import createEnrollmentProcessor from '../../verification/processor/EnrollmentProcessor' import makeServer from '../../server-test' import { getCreds, getToken } from '../../__util__' +import createFvMockHelper from '../../verification/api/__tests__/__util__' +import { enrollmentNotFoundMessage } from '../../verification/utils/constants' +import { normalizeIdentifiers } from '../../verification/utils/utils' //import testFaceMock from './face.json' @@ -13,7 +19,13 @@ describe('goodidAPI', () => { let server let token let creds + + let fvMock + let fvMockHelper + const enrollmentProcessor = createEnrollmentProcessor(storage) + const issueLocationCertificateUri = '/goodid/certificate/location' + const issueIdentityCertificateUri = '/goodid/certificate/identity' const verifyCertificateUri = '/goodid/certificate/verify' const assertCountryCode = @@ -27,7 +39,7 @@ describe('goodidAPI', () => { } const setUserData = ({ mobile, ...data }) => - UserDBPrivate.updateUser({ + storage.updateUser({ identifier: creds.address, mobile: mobile ? sha3(mobile) : null, ...data @@ -78,15 +90,23 @@ describe('goodidAPI', () => { beforeAll(async () => { jest.setTimeout(50000) + + creds = await getCreds(true) + await storage.addUser({ identifier: creds.address }) + server = await makeServer() - creds = await getCreds() token = await getToken(server, creds) + fvMock = new MockAdapter(enrollmentProcessor.provider.api.http) + fvMockHelper = createFvMockHelper(fvMock) + console.log('goodidAPI: server ready') console.log({ server }) }) beforeEach(async () => { + fvMock.reset() + await setUserData({ mobile: null, smsValidated: false @@ -94,6 +114,8 @@ describe('goodidAPI', () => { }) afterAll(async () => { + await storage.deleteUser({ identifier: creds.address }) + await new Promise(res => server.close(err => { console.log('verificationAPI: closing server', { err }) @@ -104,7 +126,9 @@ describe('goodidAPI', () => { test('GoodID endpoints returns 401 without credentials', async () => { await Promise.all( - [issueLocationCertificateUri, verifyCertificateUri].map(uri => request(server).post(uri).send({}).expect(401)) + [issueLocationCertificateUri, issueIdentityCertificateUri, verifyCertificateUri].map(uri => + request(server).post(uri).send({}).expect(401) + ) ) }) @@ -210,6 +234,48 @@ describe('goodidAPI', () => { .expect(assertCountryCode('UA')) }) + test('Identity certificate: should fail on empty data', async () => { + await request(server) + .post(issueIdentityCertificateUri) + .send({}) + .set('Authorization', `Bearer ${token}`) + .expect(400, { + success: false, + error: 'Failed to verify identify: missing face verification ID' + }) + }) + + test('Identity certificate: should fail if face id does not matches g$ account', async () => { + const { status, body } = await request(server) + .post(issueIdentityCertificateUri) + .send({ + enrollmentIdentifier: + '0x5efe0a7c45d3a07ca7faf5c09c62eee8bb944e1087594b2b951e00fb29f8318912bd8b8b0d72ddf34d99ed0eeb3574237c7ba02e8b74ae6ed107b5337e8df79e1c' + }) + .set('Authorization', `Bearer ${token}`) + + expect(status).toBe(400) + expect(body).toHaveProperty('success', false) + expect(body).toHaveProperty('error') + expect(body.error).toStartWith("Identifier signer doesn't match user") + }) + + test('Identity certificate: should fail if face record does not exist', async () => { + const enrollmentIdentifier = creds.fvV2Identifier + const { v2Identifier } = normalizeIdentifiers(enrollmentIdentifier) + + fvMockHelper.mockEnrollmentNotFound(v2Identifier) + + await request(server) + .post(issueIdentityCertificateUri) + .send({ enrollmentIdentifier }) + .set('Authorization', `Bearer ${token}`) + .expect(400, { + success: false, + error: enrollmentNotFoundMessage + }) + }) + test('Verify certificate: should fail on empty data', async () => { await request(server).post(verifyCertificateUri).send({}).set('Authorization', `Bearer ${token}`).expect(400, { success: false, diff --git a/src/server/goodid/goodid-middleware.js b/src/server/goodid/goodid-middleware.js index 90c299e8..94d4e50c 100644 --- a/src/server/goodid/goodid-middleware.js +++ b/src/server/goodid/goodid-middleware.js @@ -160,13 +160,17 @@ export default function addGoodIDMiddleware(app: Router, utils, storage) { const { enrollmentIdentifier, fvSigner } = body const { gdAddress } = user - const processor = createEnrollmentProcessor(storage, log) - try { - verifyIdentifier(enrollmentIdentifier, gdAddress) + const processor = createEnrollmentProcessor(storage, log) + + if (!enrollmentIdentifier) { + throw new Error('Failed to verify identify: missing face verification ID') + } const { v2Identifier, v1Identifier } = normalizeIdentifiers(enrollmentIdentifier, fvSigner) + verifyIdentifier(enrollmentIdentifier, gdAddress) + // here we check if wallet was registered using v1 of v2 identifier const [isV2, isV1] = await Promise.all([ processor.isIdentifierExists(v2Identifier), diff --git a/src/server/verification/utils/utils.js b/src/server/verification/utils/utils.js index 202cd633..2689b979 100644 --- a/src/server/verification/utils/utils.js +++ b/src/server/verification/utils/utils.js @@ -23,6 +23,6 @@ export const verifyIdentifier = (enrollmentIdentifier, gdAddress) => { if (strcasecmp(signer, gdAddress)) { // returns 0 if equals - throw new Error(`identifier signer doesn't match user ${signer} != ${gdAddress}`) + throw new Error(`Identifier signer doesn't match user ${signer} != ${gdAddress}`) } } From b00bd274feb9c90c1a8aae8aac2f82fff7b1d553 Mon Sep 17 00:00:00 2001 From: John Smith Date: Mon, 18 Mar 2024 19:48:32 +0200 Subject: [PATCH 10/12] add issue identity certificate test --- src/server/goodid/__tests__/goodidAPI.js | 70 ++++++++++++++++--- src/server/goodid/goodid-middleware.js | 8 +-- src/server/goodid/utils.js | 7 +- .../api/__tests__/__util__/index.js | 5 +- 4 files changed, 74 insertions(+), 16 deletions(-) diff --git a/src/server/goodid/__tests__/goodidAPI.js b/src/server/goodid/__tests__/goodidAPI.js index 9578e5e8..af6c5004 100644 --- a/src/server/goodid/__tests__/goodidAPI.js +++ b/src/server/goodid/__tests__/goodidAPI.js @@ -13,7 +13,9 @@ import createFvMockHelper from '../../verification/api/__tests__/__util__' import { enrollmentNotFoundMessage } from '../../verification/utils/constants' import { normalizeIdentifiers } from '../../verification/utils/utils' -//import testFaceMock from './face.json' +import facePhotoMock from './face.json' +import { getSubjectId } from '../veramo' +import { getRecognitionClient } from '../aws' describe('goodidAPI', () => { let server @@ -24,6 +26,10 @@ describe('goodidAPI', () => { let fvMockHelper const enrollmentProcessor = createEnrollmentProcessor(storage) + let detectFaces + let detectFacesMock = jest.fn() + const awsClient = getRecognitionClient() + const issueLocationCertificateUri = '/goodid/certificate/location' const issueIdentityCertificateUri = '/goodid/certificate/identity' const verifyCertificateUri = '/goodid/certificate/verify' @@ -31,7 +37,7 @@ describe('goodidAPI', () => { const assertCountryCode = code => ({ body }) => { - const { countryCode } = get(body, 'ceriticate.credentialSubject', {}) + const { countryCode } = get(body, 'certificate.credentialSubject', {}) if (countryCode !== code) { throw new Error(`expected ${code}, got ${countryCode}`) @@ -84,13 +90,12 @@ describe('goodidAPI', () => { } } - //const testEnrollmentIdentifier = '0x5efe0a7c45d3a07ca7faf5c09c62eee8bb944e1087594b2b951e00fb29f8318912bd8b8b0d72ddf34d99ed0eeb3574237c7ba02e8b74ae6ed107b5337e8df79e1c' - - //https://goodid.gooddollar.org/?account=0xc218C7bB7F87a544EB7dCC9D776131A75E362d9C&chain=122&fvsig=0x5efe0a7c45d3a07ca7faf5c09c62eee8bb944e1087594b2b951e00fb29f8318912bd8b8b0d72ddf34d99ed0eeb3574237c7ba02e8b74ae6ed107b5337e8df79e1c&firstname=Oleksii+Serdiukov&rdu=http%3A%2F%2Flocalhost%3A3000%2Fhome%2Fgooddollar - beforeAll(async () => { jest.setTimeout(50000) + detectFaces = awsClient.detectFaces + awsClient.detectFaces = detectFacesMock + creds = await getCreds(true) await storage.addUser({ identifier: creds.address }) @@ -105,15 +110,20 @@ describe('goodidAPI', () => { }) beforeEach(async () => { - fvMock.reset() - await setUserData({ mobile: null, smsValidated: false }) }) + afterEach(() => { + fvMock.reset() + detectFacesMock.mockReset() + }) + afterAll(async () => { + awsClient.detectFaces = detectFaces + await storage.deleteUser({ identifier: creds.address }) await new Promise(res => @@ -276,6 +286,50 @@ describe('goodidAPI', () => { }) }) + test('Identity certificate: should issue certificate from face image', async () => { + const enrollmentIdentifier = creds.fvV2Identifier + const { v2Identifier } = normalizeIdentifiers(enrollmentIdentifier) + + fvMockHelper.mockEnrollmentFound(v2Identifier, facePhotoMock) + + detectFacesMock.mockReturnValue({ + promise: async () => ({ + FaceDetails: [ + { + Gender: { + Value: 'Male' + }, + AgeRange: { + Low: 30 + } + } + ] + }) + }) + + const { status, body } = await request(server) + .post(issueIdentityCertificateUri) + .send({ enrollmentIdentifier }) + .set('Authorization', `Bearer ${token}`) + + expect(status).toBe(200) + expect(body).toHaveProperty('success', true) + + expect(body).toHaveProperty('certificate.type', [ + 'VerifiableCredential', + 'VerifiableIdentityCredential', + 'VerifiableGenderCredential', + 'VerifiableAgeCredential' + ]) + + expect(body).toHaveProperty('certificate.credentialSubject', { + id: getSubjectId(creds.address), + unique: true, + gender: 'Male', + age: { min: 30 } + }) + }) + test('Verify certificate: should fail on empty data', async () => { await request(server).post(verifyCertificateUri).send({}).set('Authorization', `Bearer ${token}`).expect(400, { success: false, diff --git a/src/server/goodid/goodid-middleware.js b/src/server/goodid/goodid-middleware.js index 94d4e50c..75d47b6c 100644 --- a/src/server/goodid/goodid-middleware.js +++ b/src/server/goodid/goodid-middleware.js @@ -72,9 +72,9 @@ export default function addGoodIDMiddleware(app: Router, utils, storage) { const { longitude, latitude } = get(body, 'geoposition.coords', {}) const issueCertificate = async countryCode => { - const ceriticate = await utils.issueCertificate(gdAddress, Location, { countryCode }) + const certificate = await utils.issueCertificate(gdAddress, Location, { countryCode }) - res.json({ success: true, ceriticate }) + res.json({ success: true, certificate }) } try { @@ -186,12 +186,12 @@ export default function addGoodIDMiddleware(app: Router, utils, storage) { const { auditTrailBase64 } = await processor.getEnrollment(faceIdentifier, log) const estimation = await utils.ageGenderCheck(auditTrailBase64) - const ceriticate = await utils.issueCertificate(gdAddress, [Identity, Gender, Age], { + const certificate = await utils.issueCertificate(gdAddress, [Identity, Gender, Age], { unique: true, ...estimation }) - res.json({ success: true, ceriticate }) + res.json({ success: true, certificate }) } catch (exception) { const { message } = exception diff --git a/src/server/goodid/utils.js b/src/server/goodid/utils.js index 947f0cf9..a78224de 100644 --- a/src/server/goodid/utils.js +++ b/src/server/goodid/utils.js @@ -2,7 +2,7 @@ import axios from 'axios' import { PhoneNumberUtil } from 'google-libphonenumber' import { substituteParams } from '../utils/axios' -import { flatten, get, toUpper } from 'lodash' +import { flatten, get, isUndefined, negate, pickBy, toUpper } from 'lodash' import { getAgent, getSubjectId } from './veramo' import { detectFaces } from './aws' @@ -66,10 +66,13 @@ export class GoodIDUtils { async ageGenderCheck(imageBase64) { const { FaceDetails } = await detectFaces(imageBase64) const [{ AgeRange, Gender }] = FaceDetails + const { Value: gender } = Gender const { Low: min, High: max } = AgeRange - return { gender, age: { min, max } } + const age = pickBy({ min, max }, negate(isUndefined)) // filter up undefined + + return { gender, age } } async issueCertificate(gdAddress, credentials, payload = {}) { diff --git a/src/server/verification/api/__tests__/__util__/index.js b/src/server/verification/api/__tests__/__util__/index.js index e642ed0a..5f3d37aa 100644 --- a/src/server/verification/api/__tests__/__util__/index.js +++ b/src/server/verification/api/__tests__/__util__/index.js @@ -100,11 +100,12 @@ export default zoomServiceMock => { const mockFailedSessionToken = (withMessage = null) => zoomServiceMock.onGet('/session-token').reply(403, mockErrorResponse(withMessage)) - const mockEnrollmentFound = enrollmentIdentifier => + const mockEnrollmentFound = (enrollmentIdentifier, customEnrollmentData = {}) => zoomServiceMock.onGet(enrollmentUri(enrollmentIdentifier)).reply(200, { - externalDatabaseRefID: enrollmentIdentifier, faceMapBase64: Buffer.alloc(32).toString(), auditTrailBase64: 'data:image/png:FaKEimagE==', + ...customEnrollmentData, + externalDatabaseRefID: enrollmentIdentifier, ...successResponse }) From f0ffc1d5ee0a062dd8c24021c079ee561f671a9f Mon Sep 17 00:00:00 2001 From: johnsmith-gooddollar <89783679+johnsmith-gooddollar@users.noreply.github.com> Date: Mon, 18 Mar 2024 19:56:25 +0200 Subject: [PATCH 11/12] Update src/server/goodid/goodid-middleware.js --- src/server/goodid/goodid-middleware.js | 40 -------------------------- 1 file changed, 40 deletions(-) diff --git a/src/server/goodid/goodid-middleware.js b/src/server/goodid/goodid-middleware.js index 75d47b6c..37c8c34d 100644 --- a/src/server/goodid/goodid-middleware.js +++ b/src/server/goodid/goodid-middleware.js @@ -258,43 +258,3 @@ export default function addGoodIDMiddleware(app: Router, utils, storage) { }) ) } - -/* - -app.post( - '/verify/agegender', - passport.authenticate('jwt', { session: false }), - requestRateLimiter(1, 1), - wrapAsync(async (req, res) => { - const { user, log } = req - let { v1Identifier, v2Identifier } = req.body - const { gdAddress } = user - - const zoomProvider = getZoomProvider() - - // for v2 identifier - verify that identifier is for the address we are going to whitelist - await verifyFVIdentifier(v2Identifier, gdAddress) - - // TODO: processor & normalize - v2Identifier = v2Identifier.slice(0, 42) - v1Identifier = v1Identifier.replace('0x', '') // wallet will also supply the v1 identifier as fvSigner, we remove '0x' for public address - - // here we check if wallet was registered using v1 of v2 identifier - const [recordV2, recordV1] = await Promise.all([ - zoomProvider.getEnrollment(v2Identifier, log), - v1Identifier && zoomProvider.getEnrollment(v1Identifier, log) - ]) - - const record = recordV2 || recordV1 - if (!record) throw new Error('face record not found') - const { auditTrailBase64 } = record - const { FaceDetails } = await detectFaces(auditTrailBase64) - log.info({ FaceDetails }) - await Promise.all([ - // semaphore.enrollAge(FaceDetails[0].AgeRange), - // semaphore.enrollGender(FaceDetails[0].Gender.Value) - ]) - - res.json({ ok: 1 }) - }) -)*/ From 20ced9045f125865b79f162bfe1643e4366d089c Mon Sep 17 00:00:00 2001 From: John Smith Date: Mon, 18 Mar 2024 20:01:41 +0200 Subject: [PATCH 12/12] fix FV test --- .../verification/__tests__/verificationAPI.js | 114 ++++++------------ 1 file changed, 35 insertions(+), 79 deletions(-) diff --git a/src/server/verification/__tests__/verificationAPI.js b/src/server/verification/__tests__/verificationAPI.js index 8b17bdd2..6404791d 100644 --- a/src/server/verification/__tests__/verificationAPI.js +++ b/src/server/verification/__tests__/verificationAPI.js @@ -113,14 +113,10 @@ describe('verificationAPI', () => { assign(enrollmentResult, { resultBlob }) } - return request(server) - .put(enrollmentUri) - .send(payload) - .set('Authorization', `Bearer ${token}`) - .expect(200, { - success: true, - enrollmentResult - }) + return request(server).put(enrollmentUri).send(payload).set('Authorization', `Bearer ${token}`).expect(200, { + success: true, + enrollmentResult + }) } const testDisposalState = async isDisposing => { @@ -210,42 +206,25 @@ describe('verificationAPI', () => { }) test('Face verification endpoints returns 401 without credentials', async () => { - await request(server) - .post(licenseUri()) - .send({}) - .expect(401) + await request(server).post(licenseUri()).send({}).expect(401) - await request(server) - .post(sessionUri) - .send({}) - .expect(401) + await request(server).post(sessionUri).send({}).expect(401) - await request(server) - .put(enrollmentUri) - .send(payload) - .expect(401) + await request(server).put(enrollmentUri).send(payload).expect(401) - await request(server) - .get(enrollmentUri) - .expect(401) + await request(server).get(enrollmentUri).expect(401) - await request(server) - .delete(enrollmentUri) - .expect(401) + await request(server).delete(enrollmentUri).expect(401) }) test('POST /verify/face/license/:licenseType returns 200, success: true and license', async () => { Config.zoomProductionMode = true helper.mockSuccessLicenseKey(licenseType, licenseKey) - await request(server) - .post(licenseUri()) - .send({}) - .set('Authorization', `Bearer ${token}`) - .expect(200, { - success: true, - license: licenseKey - }) + await request(server).post(licenseUri()).send({}).set('Authorization', `Bearer ${token}`).expect(200, { + success: true, + license: licenseKey + }) }) test('POST /verify/face/license/:licenseType returns 400, success: false if Zoom API fails', async () => { @@ -254,51 +233,35 @@ describe('verificationAPI', () => { Config.zoomProductionMode = true helper.mockFailedLicenseKey(licenseType, message) - await request(server) - .post(licenseUri()) - .send({}) - .set('Authorization', `Bearer ${token}`) - .expect(400, { - success: false, - error: message - }) + await request(server).post(licenseUri()).send({}).set('Authorization', `Bearer ${token}`).expect(400, { + success: false, + error: message + }) }) test("POST /verify/face/license/:licenseType returns 400, success: false when license type isn't valid", async () => { Config.zoomProductionMode = true - await request(server) - .post(licenseUri('unknown')) - .send({}) - .set('Authorization', `Bearer ${token}`) - .expect(400, { - success: false, - error: 'Invalid input' - }) + await request(server).post(licenseUri('unknown')).send({}).set('Authorization', `Bearer ${token}`).expect(400, { + success: false, + error: 'Invalid input' + }) }) test('POST /verify/face/license/:licenseType executes in production mode only', async () => { - await request(server) - .post(licenseUri()) - .send({}) - .set('Authorization', `Bearer ${token}`) - .expect(400, { - success: false, - error: 'Cannot obtain production license running non-production mode.' - }) + await request(server).post(licenseUri()).send({}).set('Authorization', `Bearer ${token}`).expect(400, { + success: false, + error: 'Cannot obtain production license running non-production mode.' + }) }) test('POST /verify/face/session returns 200, success: true and sessionToken', async () => { helper.mockSuccessSessionToken(sessionToken) - await request(server) - .post(sessionUri) - .send({}) - .set('Authorization', `Bearer ${token}`) - .expect(200, { - success: true, - sessionToken - }) + await request(server).post(sessionUri).send({}).set('Authorization', `Bearer ${token}`).expect(200, { + success: true, + sessionToken + }) }) test('POST /verify/face/session returns 400, success: false if Zoom API fails', async () => { @@ -306,14 +269,10 @@ describe('verificationAPI', () => { helper.mockFailedSessionToken(message) - await request(server) - .post(sessionUri) - .send({}) - .set('Authorization', `Bearer ${token}`) - .expect(400, { - success: false, - error: message - }) + await request(server).post(sessionUri).send({}).set('Authorization', `Bearer ${token}`).expect(400, { + success: false, + error: message + }) }) test('PUT /verify/face/:enrollmentIdentifier returns 400 when payload is invalid', async () => { @@ -479,7 +438,7 @@ describe('verificationAPI', () => { .expect(400) expect(result.body.success).toEqual(false) - expect(result.body.error).toStartWith("identifier signer doesn't match user") + expect(result.body.error).toStartWith("Identifier signer doesn't match user") }) test('DELETE /verify/face/:enrollmentIdentifier returns 200 and success = true if v2 signature is valid', async () => { @@ -503,10 +462,7 @@ describe('verificationAPI', () => { helper.mockEnrollmentFound(enrollmentIdentifier) mockWhitelisted() - await request(server) - .delete(enrollmentUri) - .query({ signature }) - .set('Authorization', `Bearer ${token}`) + await request(server).delete(enrollmentUri).query({ signature }).set('Authorization', `Bearer ${token}`) await testDisposalState(true) })