Skip to content

본인확인-API 개발 가이드

  • 버전 : 1.0.7.1
  • 날짜 : 2025-05-28

1. 본인확인-API 서비스

  • 본인확인-API 서비스 흐름도

본인확인-API 서비스 흐름도

2. 본인확인-API 개발 절차

2.1 API 연동 업무절차

  1. 이용기관의 이동통신사 본인확인 가입절차를 위한 신청서를 제출합니다.

    • 이동통신사 본인확인 심사가 완료되어야 서비스 가능합니다.

    • 도메인 등록 정보, 본인확인-API 사용시 방화벽 오픈 정보등을 기입하여야 합니다.

      Info

  2. 본인확인서비스 담당자가 이동통신사 본인확인 등록 심사결과를 전달합니다.

    • ARS 점유인증 이용기관은 본인확인 담당자와 ARS 관련 추가 업무절차를 논의하셔야 합니다.

      Info

      • ARS 점유인증 이용기관 중 별도의 안내멘트 설정
      • ARS 점유인증 인증 외 추가정보(회사명, 추가 사용자 확인정보) 확인등 추가정보 처리가 있을 경우 업무협의 필요

  3. 본인확인서비스 담당자가 운영서버에 본인확인-API 서비스 운영 등록을 진행합니다.

  4. 본인확인 개발용 서비스키 파일을 본인확인서비스 운영자에게 전달받아야 합니다.

    • 본인확인 개발용 서비스키 파일 : mok_keyInfo.dat

      Note

      본인확인 개발용 서비스키는 본인확인서비스 개발서버에서만 사용 가능합니다.

  5. 본인확인-API 기능 테스트를 진행합니다.

    1. 가이드 내 샘플페이지 적용 테스트

      Info

      • 샘플페이지 테스트로 사전 기능확인을 하여야 본인확인서비스 담당자의 원활한 기술지원을 받으실 수 있습니다.

    2. 이용기관 웹페이지에 본인확인서비스 기능 적용

  6. 본인확인 운영용 서비스키 파일을 본인확인서비스 운영자에게 전달받아야 합니다.

    • 본인확인 운영용 서비스키 파일 : mok_keyInfo.dat
      • 키파일은 반드시 서버의 안전한 로컬경로에 별도 저장.
      • 웹URL 경로에 파일이 있을경우 키파일이 외부에 노출될 수 있음 주의

  7. 본인확인 운영용 서비스키를 이용기관 운영시스템에 적용합니다.

2.2 API 방화벽 설정

  • 본인확인-API 서버 방화벽 오픈

    • 운영담당자에게 이용기관에서 본인확인서버로 요청하는 IP정보 등록 요청

      • 이용기관에서 본인확인서비스로 요청하는 서버 공인 IP

      • 전용선 이용시 이용기관 서버에서 요청하는 내부 IP 또는 공인 IP

  • 본인확인서비스 본인확인-API 서비스 이용시 이용기관 Outbound 방화벽 오픈 정보

    • 운영) cert-dir.mobile-ok.com (218.50.1.151)

    • 개발) scert-dir.mobile-ok.com (218.50.1.157)

2.3 API 연동 준비

본인확인서비스 적용을 위해서는 본인확인서비스 담당자에게 본인확인-API 연동을 위한 신청 및 이동통신사 본인확인 등록을 완료 후 본인확인의 아래 정보를 획득하여야 합니다.

  • 서비스 등록 시 확인 정보

  • 본인확인에 등록된 표준창을 사용할 수 있는 도메인 리스트

    • 등록되지 않았을 경우 운영담당자에게 등록 요청

  • 본인확인 이용기관 암복호화키

    • 개발용 키와 운영용 키가 다르므로 각각 용도에 맞는 키 획득

      Warning

      • 신청시 등록한 도메인과 발급받은 본인확인 이용기관 암복호화키정보가 신청하신 등록정보와 동일하여야 서비스 사용이 가능
      • 등록 정보와 일치하지 않을 경우 “등록되지 않은 사이트입니다” 오류가 발생

  • 서비스 등록 후 다운로드 또는 전달 받은 본인확인 암복호화키 정보 (mok_keyInfo.dat)

  • 본인확인 암호화키 ID

  • 본인확인 이용기관 암복호화 비밀키

    본인확인 이용기관 암복호화키 유의사항

    • 본인확인-표준창 암복호화 키파일은 반드시 외부에 유출되지 않도록 보관 필요
    • 본인확인-표준창 암복호화 키파일은 반드시 웹에서 접근되지 않는 서버의 안전한 로컬경로에 별도 저장
    • 웹URL 경로에 본인확인-표준창 암복호화 키파일이 있을경우 보안키가 외부에 노출됨

  • 본인확인-표준창 HTTP 이용 정보

  • HTTPS 암호화 통신 : 사용자 브라우져 또는 이용기관 서버에서 본인확인 서비스 결과 요청시 TLS 1.2 이상 지원하여야 함

  • HTTP 메소드 : POST

  • Charset : utf-8

2.4 API 연동 라이브러리

  • 본인확인 개발언어 별 라이브러리

    bouncycastle 라이브러리 사용시 주의점

    한 프로젝트 내에서 bouncycastle 라이브러리를 여러버전 사용 및 여러종류의 암호라이브러리를 사용할 경우 일부 오류가 발생할 수 있습니다.

    • 키관리 라이브러리 phpseclib 1.0 지원 : mobileokManager-phpseclib1.0_1.0.2.zip (필수)
      • phpseclib_path_1.0.php : phpseclib 1.0 에서 사용하는 클래스 경로 설정
      • mobileOK_manager_phpseclib_v1.0_v1.0.2.php : 본인확인 연동 라이브러리
      • phpseclib_path_1.0.php의 경로를 mobileOK_manager_phpseclib_v1.0_v1.0.2.php에 직접 작성 (작성 필수)
        mobileOK_manager_phpseclib_v1.0_v1.0.2.php 파일 수정정보
        <?php
    $mok_path = './phpseclib_path_1.0.php';
?>
    • 키관리 라이브러리 phpseclib 3.0 이상 지원 : mobileokManager-phpseclib3.0_1.0.2.zip (필수)
      • phpseclib_path_3.0.php : phpseclib에서 사용하는 클래스 경로 (Composer의 autoload.php 파일 경로)
      • mobileOK_manager_phpseclib_v3.0_v1.0.2.php : 본인확인 연동 라이브러리
      • phpseclib_path_3.0.php의 경로를 mobileOK_manager_phpseclib_v3.0_v1.0.2.php에 직접 작성 (작성 필수)
        mobileOK_manager_phpseclib_v3.0_v1.0.2.php 파일 수정정보
        <?php
    $mok_path = './phpseclib_path_3.0.php';
?>
    • phpseclib 버전별 예제 유의사항
      • phpseclib-v1.0
        • PHP 5.5 미만 버전 이용시 예제 유의사항
          • 제공하는 예제 사용시 PHP 5.5 버전 이상 사용 필수
          • PHP 5.4.x 버전 이용시 curl 라이브러리를 사용할 수 없으므로 https 송수신 기능 구현 필요
          • PHP 5.3.x 버전 이용시 json_encode 함수를 사용할 수 없으므로 json encode 기능 구현 필요(PHP 5.4.x 유의사항 포함)
      • phpseclib-v3.0.0
        • 해당사항 없음
    • PHP 5.6 버전 이용시 예제 유의사항
      • https 전송예제에서 php.ini 추가설정 필요 DEPRECATED경고문과 WARNING경고문을 출력하여 데이터와 같이 송신되는 이슈 발생
        $HTTP_RAW_POST_DATA를 사용하지 않는 경우
        #php.ini
always_populate_raw_post_data = -1
        $HTTP_RAW_POST_DATA를 사용하는 경우
        #php.ini
error_reporting = E_ALL & ~E_DEPRECATED & ~E_WARNING
    • PHP 7.0 (64bit) / PHP 7.1 (64bit) 이용시 Composer설치 및 C라이브러리 사용시 이슈 발생
    • openssl암호화 모듈을 사용히는 코드 php.ini 추가설정 필요 
      #php.ini
# Windows
extension = php_openssl.dll
# Unix, Linux
extension = php_openssl.so
    • PHP 암호화 보안라이브러리 phpseclib 설치 (필수)
    • PHP 데이터 전송 라이브러리 php.ini 설정 
      extension_dir = "ext"
# Windows 
extension = php_curl.dll
# Unix, Linux 
extension = php_curl.so
default_charset = UTF-8
    • Node.js의 기본 모듈인 CommonJS기반으로 구현
    • 키관리 라이브러리 : mobileokManager-Nodejs_1.0.3.zip (필수)
    • Node.js 모듈 이용시 유의사항 (필수)

    • npm install list

      • ‘cors’
      • ‘express’
      • ‘express-session’
      • ‘body-parser’
      • ‘ejs’
      • ‘fs’
      • ‘crypto’
      • ‘axios’
      • ‘urlencode’

    • Node.js 예제 유의사항

      • https 전송예제에서 사용하는 ‘axios’ 라이브러리는 비동기 방식으로 지원하며 동기방식으로 지원하는 최소 버전은 Node.js 14.0.0 이상 권장
      • EJS 템플릿 엔진 모듈를 사용하는 경우 ejs파일의 경로가 root/views/파일명.ejs로 설정되어 있거나 views폴더 안에 ejs파일이 위치하거나, 경로를 직접 설정하여 사용
      • 13.7.0 버전에서 axios를 사용할 경우 아래 오류가 발생하므로 14.0.0 이상 권장 
        (node:18720) ExperimentalWarning: Conditional exports is an experimental feature. This feature could change at any time
    • **.NET framework v4.5 이상 지원 **

    • ASP.NET 암호라이브러리 (필수)

    • ASP.NET 암호화 확장 라이브러리 : RSA-OAEP, AES256 암호알고리즘 사용 (필수)

      Bouncycastle 암호라이브러리 .NET 설치 방법

      • Bouncycastle dll 다운로드 설치 
            1. Bouncycastle dll 다운로드 파일 압축 해제
    2. "3.2 표준창 예제 구조"와 같이 .NET 구조의 bin 디렉토리에 파일 복사
    • ASP.NET JSON 이용 라이브러리 (필수)
      • Newtonsoft.Json 라이브러리 다운로드 Newtonsoft.Json
        • 13.0.3기준 상위 버전

    bouncycastle 라이브러리 사용시 주의점

    한 프로젝트 내에서 bouncycastle 라이브러리를 여러버전 사용 및 여러 종류의 암호라이브러리를 사용할 경우 일부 오류가 발생할 수 있습니다.

    • .NET Core v2.0 이상 지원

    • .NET Core 암호라이브러리 (필수)

      csproj 라이브러리 참조 방법

      • 프로젝트명.csproj 내 라이브러리 참조 
            <ItemGroup>
        <Reference Include="mobileOKManager.netcore">
            <HintPath>"mobileOKManager.netcore.dll파일 서버 절대경로"\mobileOKManager.netcore.dll</HintPath>
        </Reference>
    </ItemGroup>

    • .NET Core 암호화 확장 라이브러리 : RSA-OAEP, AES256 암호알고리즘 사용 (필수)

      • Bouncycastle 암호라이브러리 2.0.0 이상 다운로드 Bouncycastle

      Bouncycastle 암호라이브러리 .NET 설치 방법

      • Bouncycastle NutGet 설치버전 설치 
            > NuGet\Install-Package BouncyCastle.Cryptography -Version 2.2.1

    • .NET JSON 이용 라이브러리 (필수)

      • Newtonsoft.Json 라이브러리 다운로드 Newtonsoft.Json
        • 13.0.3기준 상위 버전

    bouncycastle 라이브러리 사용시 주의점

    한 프로젝트 내에서 bouncycastle 라이브러리를 여러버전 사용 및 여러 종류의 암호라이브러리를 사용할 경우 일부 오류가 발생할 수 있습니다.

2.5 API 연동시 고려사항

  • 본인확인-API TLS 1.2 통신오류 고려 사항

    TLS 통신 오류 “Unable to find certificate chain.” 또는 “unable to find valid certification path to requested target” 발생시 처리 방법

    • 오류 내용

      • “TLS 통신을 위한 인증기관 인증서 유효성을 확인할수 없다.” 라는 의미 입니다. (Java 버전에 따라 표시되는 메시지를 달라질수 있음)
      • 즉, 클라이언트의 루트인증서저장소(cacerts)에 서버로부터 전달받은 인증서를 검증할 루트인증서가 없다면 신뢰성 검증을 할 수 없어서 오류가 발생합니다.

    • 해결 방안

      • 클라이언트의 루트인증서저장소(cacerts)에 서버의 인증서를 발급한 인증기관의 루트인증서를 등록해야 합니다. 해당 루트인증서를 다운받거나 전달받은 후 아래의 명령어로 등록할 수 있습니다. 
        - 명령어 : $ keytool -importcert -alias 등록할 별칭 -keystore ${JAVA_HOME}/jre/lib/security/cacerts -file 루트인증서
  (예시) : keytool -importcert -alias DigiCertGlobalRootG2 -keystore ${JAVA_HOME}/jre/lib/security/cacerts -file DigiCertGlobalRootG2.crt.pem
          > cacerts에 설정된 비밀번호 : changeit

    • Root 인증서 다운로드 : DigiCert Global Root G2 Download PEM

3. 본인확인-API 개발 준비

3.1 API 연동 순서

  1. 본인확인-API 거래토큰 전송 및 수신

  2. 본인확인-API 인증요청 전송 및 수신

  3. (본인확인 + ARS 점유인증 전용 처리) 본인확인-API ARS전화요청 전송 및 수신

  4. 본인확인-API 결과요청 전송 및 수신

3.2 API 예제 구조

  • 본인확인-API 개발예제 구조

    .
├─ WEB-INF/
│   └─ lib/
│       └─ mobileOKManager-jdk1.8_1.0.1.jar
└─ mok/
    ├─ mok_api_gettoken.jsp
    ├─ mok_api_request.jsp
    ├─ mok_ars_call.jsp
    └─ mok_api_result.jsp

    .
├─ WEB-INF/
│   └─ lib/
│       ├─ bcpkix -jdk15to18-xxx.jar
│       ├─ bcprov -jdk15to18-xxx.jar
│       ├─ bctls -jdk15to18-xxx.jar
│       ├─ bcutil -jdk15to18-xxx.jar
│       └─ mobileOKManager-jdk1.6_1.0.1.jar
└─ mok/
    ├─ mok_api_gettoken.jsp
    ├─ mok_api_request.jsp
    ├─ mok_ars_call.jsp
    └─ mok_api_result.jsp

    .
└─ mok/
    ├─ mobileOK_manager_phpseclib_v3.0_v1.0.2.php
    ├─ composer.json
    ├─ composer.lock
    ├─ phpseclib_path_3.0.php
    ├─ mok_api_gettoken.php
    ├─ mok_api_request.php
    ├─ mok_ars_call.php
    ├─ mok_api_result.php
    └─ vendor/
        └─ composer/
            ├─ paragonie
            ├─ phpseclib
            └─ autoload.php

    .
└─ mok/
    ├─ mobileOK_manager_phpseclib_v1.0_v1.0.2.php
    ├─ phpseclib_path_1.0.php
    ├─ mok_api_gettoken.php
    ├─ mok_api_request.php
    ├─ mok_ars_call.php
    ├─ mok_api_result.php
    └─ phpseclib-1.0.20/
        └─ phpseclib/
            ├─ Crypt
            ├─ File
            ├─ Math
            ├─ Net
            ├─ System
            ├─ bootstrap.php
            └─ openssl.cnf

    .
└─ mok/
    ├─ mok_Key_Manager_v1.0.3.js
    ├─ mok_api_server.js
    ├─ package.json
    ├─ package-lock.json
    ├─ node_modules/
    └─ views/
        ├─ mok_api_gettoken.ejs
        ├─ mok_api_request.ejs
        ├─ mok_ars_call.ejs
        └─ mok_api_result.ejs

    .
├─ bin/
│   ├─ BouncyCastle.Crypto.dll
│   ├─ Newtonsoft.Json.dll
│   └─ mobileOKManager.net.dll
├─ mok/
│   ├─ mok_api_gettoken.aspx.cs
│   ├─ mok_api_request.aspx.cs
│   ├─ mok_ars_call.aspx.cs
│   ├─ mok_api_result.aspx.cs
│   ├─ mok_api_gettoken.aspx
│   ├─ mok_api_request.aspx
│   ├─ mok_ars_call.aspx
│   └─ mok_api_result.aspx
└─ Web.config

    .
├─ Controllers/
│   ├─ GetTokenController.cs
│   ├─ RequestController.cs
│   ├─ CallController.cs
│   └─ ResultController.cs
└─ Views/
    ├─ GetToken/
    │   └─ mok_api_gettoken.cshtml
    ├─ Request/
    │   └─ mok_api_request.cshtml
    ├─ Call/
    │   └─ mok_ars_call.cshtml
    └─ Result/
        └─ mok_api_result.cshtml

4. 본인확인-API 거래토큰 요청

본인확인서비스 연동을 위해 본인확인-API 거래토큰을 획득합니다. 이후 본인확인-API 서비스에서 거래토큰 정보을 이용하여 서비스를 진행합니다.

  • 본인확인서비스 거래토큰은 최초 생성 후 본인확인-API 인증요청이 실행되면 재사용 할 수 없음
  • 거래토큰 유효시간은 총 10분으로 인증 요청 후 7분내에 인증처리(이동통신사 기준) 되어야 하며 인증번호 2번 재시도 가능

  • 10분이 넘어가면 새로운 거래토큰을 생성하여 처음부터 처리

  • 본인확인-API 거래토큰 연동 URL 및 전송 정보

    • URL

      • 운영 : https://cert-dir.mobile-ok.com/agent/v1/token/get

      • 개발 : https://scert-dir.mobile-ok.com/agent/v1/token/get

    • HTTPS 암호화 통신 : TLS 1.2 이상

    • HTTP 메소드 : POST

    • Charset : utf-8

  • 본인확인-API 거래토큰 요청

    • 본인확인-API 거래토큰 요청 정보

      속성 내용 필수여부
      serviceId 이용기관 사이트 서비스 ID ●
      siteUrl 본인확인서비스 요청 이용기관 등록 도메인(예시, mobile-ok, www.mobile-ok.com) ●
      encryptReqClientInfo 암호화된 이용기관(이용기관) 거래ID 정보로 이용기관 비밀키로 암호화
      -거래 ID는 20byte 이상 50byte 미만 사용      		 ●

    • 이용기관(이용기관) 거래ID 정보 암호화 전 데이터

      • (예시) 거래ID|요청일시(YYYYMMDDhhmmss) -> DS20220629133555456594|20221212010101

    • 본인확인-API 거래토큰 요청 JSON 예시

      {
    "serviceId" : "8069e0ab-a76e-498b-be37-74d60ba5f62c",
    "siteUrl" : "www.mobile-ok.com",
    "encryptReqClientInfo" : "kMH49RaobxoHxtrACdctPOJf6F3kiGErTdIyWwJ8hT9KrGo2Lrb23+FHQ...5ZOb7aAJdS7bu2DhWhjF7tDmxQ=="
}

  • 본인확인-API 거래토큰 응답

    • 본인확인-API 거래토큰 응답 정보

      속성 값 필수여부
      encryptMOKToken 암호화된 본인확인-API 거래 토큰 ●
      publicKey 사용자 정보를 암호화 하기 위한 휴대폰본인확인서버 암호화용 공개키
      - 암호알고리즘은 RSA-OAEP를 사용      		 ●
      resultCode 응답 결과 코드
      -2000일 경우 성공
      -2000이 아닐 경우 에러 처리      		 ●
      resultMsg 응답 결과 코드가 2000이 아닐 경우 에러 메시지 ●

    • 본인확인-API 거래토큰 응답 JSON 예시

      {
    "encryptMOKToken" : "3ID+qLHC8ybosijI6BBEOSIO9lk2viKgrsAJ7mRzGkxh4HDONxb...Do240z68XAt8hU0dTcdtjGJ2r+qvRWH/UCz+MdT00tcJo=",
    "publicKey" : "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAuKmOSnlO48y5G9MFw7l7T0Hf179b9Z87g1SlskOJj...y0zPfswIDAQAB",
    "resultCode" : "2000",
    "resultMsg" : " success"
}

  • 본인확인-API 서비스 코드표

    속성 값 필수여부
    serviceType 이용상품 코드
    - “telcoAuth” : 휴대폰본인확인 SMS/PASS 인증 서비스    		 ●
    providerId 서비스 제공 이동통신사 및 서비스
    - “SKT”
    - “KT”
    - “LGU”
    - “SKTMVNO”
    - “KTMVNO”
    - “LGUMVNO”    		 ●
    reqAuthType 본인확인 인증 Type 코드, 인증번호 전송 타입 또는 인증방법
    -“PASS”    		 ●
    속성 값 필수여부
    serviceType 이용상품 코드
    - “telcoAuth” : 휴대폰본인확인 SMS/PASS 인증 서비스    		 ●
    providerId 서비스 제공 이동통신사 및 서비스
    - “SKT”
    - “KT”
    - “LGU”
    - “SKTMVNO”
    - “KTMVNO”
    - “LGUMVNO”    		 ●
    reqAuthType 본인확인 인증 Type 코드, 인증번호 전송 타입 또는 인증방법
    -“SMS”    		 ●
    usageCode 서비스 이용 코드
    - “01001” : 회원가입
    - “01002” : 정보변경
    - “01003” : ID찾기
    - “01004” : 비밀번호찾기
    - “01005” : 본인확인용
    - “01007” : 상품구매/결제
    - “01999” : 기타    		 ●
    userGender 사용자 성별, reqAuthType이 “SMS” 이용시 필수
    - “1” : 남자
    - “2”: 여자
    userNation 사용자 내외국인 정보, reqAuthType이 “SMS” 이용시 필수
    - “0” : 내국인
    - “1”: 외국인
    속성 값 필수여부
    serviceType 이용상품 코드
    - “telcoAuth” : 휴대폰본인확인 SMS/PASS 인증 서비스    		 ●
    providerId 서비스 제공 이동통신사 및 서비스
    - “SKT”
    - “KT”
    - “LGU”
    - “SKTMVNO”
    - “KTMVNO”
    - “LGUMVNO”    		 ●
    reqAuthType 본인확인 인증 Type 코드, 인증번호 전송 타입 또는 인증방법
    -“SMS”    		 ●
    usageCode 서비스 이용 코드
    - “01016” : 성인인증 (민법)
    - “01026” : 성인인증 (청소년보호법)
    		●
    userGender 사용자 성별, reqAuthType이 “SMS” 이용시 필수
    - “1” : 남자
    - “2”: 여자
    userNation 사용자 내외국인 정보, reqAuthType이 “SMS” 이용시 필수
    - “0” : 내국인
    - “1”: 외국인

  • 본인확인 거래토큰 API 요청 및 응답 예제

    mok_api_gettoken.jsp
      1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
    <%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<%@ page import="java.util.UUID" %>
<%@ page import="java.util.Calendar" %>
<%@ page import="java.util.logging.SimpleFormatter" %>
<%@ page import="java.text.SimpleDateFormat" %>
<%@ page import="java.net.HttpURLConnection" %>
<%@ page import="java.net.URL" %>
<%@ page import="java.io.*" %>
<%@ page import="java.io.IOException" %>
<%@ page import="com.dreamsecurity.json.JSONObject" %>
<%@ page import="com.dreamsecurity.json.JSONException" %>
<%@ page import="com.dreamsecurity.mobileOK.mobileOKKeyManager" %>
<%@ page import="com.dreamsecurity.mobileOK.MobileOKException" %>

<%! 
    /* 1. 본인확인 인증결과 MOKGetToken API 요청 URL */
    // private final String MOK_GET_TOKEN_URL = "https://cert-dir.mobile-ok.com/agent/v1/token/get";  // 운영
    private final String MOK_GET_TOKEN_URL = "https://scert-dir.mobile-ok.com/agent/v1/token/get";  // 개발

    /* 요청하기 버튼 클릭시 이동 JSP (mobileOK-Request JSP) */
    private final String MOK_REQUEST_JSP = "./mok_api_request.jsp";

    // 이용기관 거래ID생성시 이용기관별 유일성 보장을 위해 설정, 이용기관식별자는 이용기관코드 영문자로 반드시 수정
    private final static String PREFIX_ID = "본인확인 이용기관식별자 PREFIX";  // 8자이내 영대소문자,숫자 (예) MOK, TESTCOKR
%>

<%
    mobileOKKeyManager mobileOK = null;
    String mokReuslt = null;
    try {
        /* 2. 본인확인 키파일을 통한 비밀키 설정 */
        mobileOK = new mobileOKKeyManager();
        /* 키파일은 반드시 서버의 안전한 로컬경로에 별도 저장. 웹URL 경로에 파일이 있을경우 키파일이 외부에 노출될 수 있음 주의 */
        mobileOK.keyInit("/본인확인-API 키정보파일 Path/mok_keyInfo.dat", "키파일 패스워드");
        mobileOK.setSiteUrl("본인확인-API 등록 사이트 URL");
        mokReuslt = mobileOK_api_gettoken(mobileOK, request);
    } catch (MobileOKException e) {
        mokReuslt = setErrorMsg(e.getMessage());
    }
%>

<%!
    /* 본인확인-API 토큰요청 예제 함수 */
    public String mobileOK_api_gettoken(mobileOKKeyManager mobileOK, HttpServletRequest request) throws Exception {
        /* 3. 본인확인-API 거래요청정보 생성  */

        /* 3.1 이용기관 거래ID 생성, 20자 이상 40자 이내 이용기관 고유 트랜잭션ID (예시) 이용기관식별자+UUID, ...  */
        // - 본인확인-API 거래ID 는 유일한 값이어야 하며 기 사용한 거래ID가 있는 경우 오류 발생 
        // - 이용기관이 고유식별 ID로 유일성을 보장할 경우 고객이 이용하는 ID사용 가능 
        String sampleClientTxId = PREFIX_ID + UUID.randomUUID().toString().replaceAll("-", "");

        /* 3.2 인증 결과 검증을 위한 거래 ID 세션 저장 */
        // 동일한 세션내 요청과 결과가 동일한지 확인 및 인증결과 재사용 방지처리, 응답결과 처리 시 필수 구현
        // 세션 내 거래ID를 저장하여 검증하는 방법은 권고 사항이며, 이용기관 저장매체(DB 등)에 저장하여 검증 가능
        request.getSession().setAttribute("sessionClientTxId", sampleClientTxId);

        /* 4. 본인확인 토큰요청 데이터 설정 (아래 MOKGetTokenRequestToJsonString() 참조) */
        String MOKGetTokenRequestJsonString = MOKGetTokenRequestToJsonString(
                mobileOK
                , mobileOK.getServiceId() /* 본인확인 서비스 ID */
                , sampleClientTxId        /* 암호화된 이용기관 식별 ID */
                , mobileOK.getSiteUrl()   /* 본인확인-API 등록 사이트 URL */
                ); 

        /* 5. 본인확인 토큰요청 */
        String MOKGetTokenResponseJsonString = sendPost(MOK_GET_TOKEN_URL, MOKGetTokenRequestJsonString);

        /* 6. 본인확인 토큰요청 후 응답 데이터 설정*/
        JSONObject MOKGetTokenResponseJson = new JSONObject(MOKGetTokenResponseJsonString);
        if (!"2000".equals(MOKGetTokenResponseJson.getString("resultCode"))) {
            return MOKGetTokenResponseJson.toString();
        }

        /* 6-1. 본인확인 인증요청 API에서 이용할 데이터 설정 */
        JSONObject MOKAuthRequestData = new JSONObject();
        MOKAuthRequestData.put("encryptMOKToken", MOKGetTokenResponseJson.getString("encryptMOKToken"));
        MOKAuthRequestData.put("publicKey", MOKGetTokenResponseJson.getString("publicKey"));
        MOKAuthRequestData.put("resultCode", MOKGetTokenResponseJson.getString("resultCode"));
        MOKAuthRequestData.put("resultMsg", MOKGetTokenResponseJson.getString("resultMsg"));

        return MOKAuthRequestData.toString();
    }

    /* 본인확인-API 토큰요청 입력데이터 설정 예제 함수 */
    private String MOKGetTokenRequestToJsonString(
            mobileOKKeyManager mobileOK
            , String serviceId
            , String clientTxId
            , String siteUrl) throws MobileOKException {
        Calendar cal = Calendar.getInstance();
        SimpleDateFormat formatter = new SimpleDateFormat("yyyyMMddHHmmss");

        String reqClientInfo = clientTxId + "|" + formatter.format(cal.getTime());

        String encryptReqClientInfo = mobileOK.RSAEncrypt(reqClientInfo);

        JSONObject MOKGettokenRequestJson = new JSONObject();
        MOKGettokenRequestJson.put("serviceId", mobileOK.getServiceId()); 
        MOKGettokenRequestJson.put("encryptReqClientInfo", encryptReqClientInfo);
        MOKGettokenRequestJson.put("siteUrl", mobileOK.getSiteUrl());

        return MOKGettokenRequestJson.toString();
    }


    /* 본인확인 서버 통신 예제 함수 */
    private String sendPost(String dest, String json) throws MobileOKException {
        HttpURLConnection connection = null; 
        DataOutputStream dataOutputStream = null;
        BufferedReader bufferedReader = null;
        StringBuffer responseData = null;

        try {
            URL url = new URL(dest);
            connection = (HttpURLConnection) url.openConnection();
            connection.setRequestMethod("POST");
            connection.setRequestProperty("Content-Type", "application/json;charset=UTF-8");
            connection.setDoOutput(true);

            dataOutputStream = new DataOutputStream(connection.getOutputStream());
            dataOutputStream.writeBytes(json.toString());

            bufferedReader = new BufferedReader(
                    new InputStreamReader(connection.getInputStream())
            );
            responseData = new StringBuffer();
            String info;
            while ((info = bufferedReader.readLine()) != null) {
                responseData.append(info);
            }

            return responseData.toString();
        } catch (FileNotFoundException e) {
            throw new MobileOKException("MOK_GET_TOKEN_URL을 확인해 주세요.");
        } catch (JSONException e) {
            e.printStackTrace();
        } catch(IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (bufferedReader != null) {
                    bufferedReader.close();
                }

                if (dataOutputStream != null) {
                    dataOutputStream.close();
                }

                if (connection != null) {
                    connection.disconnect();
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

        return null;
    }

    private String setErrorMsg(String errorMsg) {
        JSONObject errorJson = new JSONObject();
        errorJson.put("resultMsg", errorMsg);

        return errorJson.toString();
    }
%>

<html>
<head>
    <meta charset="utf-8"/>
    <title>mok_api_gettoken</title>
    <script>
        const MOKAuthRequestData = <%= mokReuslt %>
        if (MOKAuthRequestData.resultCode != '2000') {
            /* 오류발생시 */
            window.alert(MOKAuthRequestData.resultCode + ', ' + MOKAuthRequestData.resultMsg);
        } else {
            document.addEventListener("DOMContentLoaded", function () {
                /* 정상작동시 */
                document.getElementById("MOKAuthRequestData").value = JSON.stringify(MOKAuthRequestData);
            });
        }

    </script>
</head>
<body>
<form action=<%= MOK_REQUEST_JSP %> method="post">
    <p>서비스별 인증요청 정보(MOKAuthInfo)를  참고하여 작성</p>
    (공통 필수) <input type="text" required id="serviceType" name="serviceType"  value="" placeholder="telcoAuth" /> 이용상품 코드 (serviceType => "telcoAuth":휴대폰본인확인, telcoAuth-LMS : "휴대폰본인확인 LMS", telcoAuth-ARSAuth : "ARS") <br>
    (공통 필수) <input type="text" required id="providerid" name="providerid" value="" placeholder="SKT" style="left-padding:10px" /> 인증 사업자 구분코드 (providerId => "SKT","KT","LGU","SKTMVNO","KTMVNO","LGUMVNO") <br>
    (공통 필수) <input type="text" required id="reqAuthType" name="reqAuthType" value="" placeholder="PASS" /> 본인확인 인증 처리 Type 코드 (reqAuthType => "SMS" : SMS인증, "PASS" : PASS앱 인증, "ARS" : "ARS") <br>
    (공통 선택) <input type="text" id="usageCode" name="usageCode" value="" placeholder="01001" /> 서비스 이용 코드 (usageCode) <br>
    (공통 필수) <input type="text" id="retTransferType" name="retTransferType" value="MOKResult" /> 요청 대상의 결과 전송 타입 (retTransferType) <br>
    (공통 필수) <input type="text" required id="userName" name="userName" placeholder="홍길동" value="" /> 이름 (userName) <br> 
    (공통 필수) <input type="tel" required id="userPhoneNum" name="userPhoneNum" value="" placeholder="숫자만 (-제외)" /> 핸드폰 번호 (userPhone) <br>
    <input type="tel" id="userBirthday" name="userBirthday" value="" placeholder="20000101" style="width:250px"/> 생년월일(8자리) (userBirthday) <br>
    <input type="text" id="userGender" name="userGender" value="" placeholder="남자 : 1, 여자 : 2" style="width:250px"/> 성별 (userGender => "1" : 남자, "2" : 여자) <br>
    <input type="text" id="userNation" name="userNation" value="" placeholder="내국인 : 0, 외국인 : 1" style="width:250px"/> 내외국인 정보 (userNation => "0" : 내국인, "1" : 외국인) <br>
    <textarea id="sendMsg" name="sendMsg" placeholder="본인확인 인증번호[000000]를 화면에 입력해주세요." style="width:250px"></textarea> SMS 전송 시 사용할 메시지로 사용할 값 (sendMsg)<br>
    <input type="text" id="replyNumber" name="replyNumber" value="" placeholder="15880000" style="width:250px"/> SMS 또는 ARS 전송 시 사용할 송신번호 (replyNumber) <br>
    <input type="text" id="arsCode" name="arsCode" placeholder="ARS-TEST-NVR-11" style="width:250px" /> 운영자와 협의 된 ARS 코드 (arsCode) <br>
    <input type="text" id="arsRequestMsg" name="arsRequestMsg" placeholder='{"companyName":"이용기관명"}' style="width:350px"/> ARS 점유인증 요청시 추가정보 입력 extension/arsRequestMsg <br>
    <input type="submit" style="width:400px; height:30px; margin-top:10px; margin-bottom:10px" value="요청하기"/><br>
    <input type="hidden" id="MOKAuthRequestData" name="MOKAuthRequestData" value=''/>
    <input type="hidden" id="normalFlag" name="normalFlag" value='Y'/>
</form>

</body>
</html>
    mok_api_gettoken.jsp
      1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
    <%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<%@ page import="java.util.UUID" %>
<%@ page import="java.util.Calendar" %>
<%@ page import="java.util.logging.SimpleFormatter" %>
<%@ page import="java.text.SimpleDateFormat" %>
<%@ page import="java.net.URL" %>
<%@ page import="java.io.*" %>
<%@ page import="java.io.IOException" %>
<%@ page import="com.dreamsecurity.json.JSONObject" %>
<%@ page import="com.dreamsecurity.json.JSONException" %>
<%@ page import="com.dreamsecurity.mobileOK.mobileOKKeyManager" %>
<%@ page import="com.dreamsecurity.mobileOK.MobileOKException" %>
<%@ page import="javax.net.ssl.SSLContext"%>
<%@ page import="java.security.Security"%>
<%@ page import="java.security.SecureRandom"%>
<%@ page import="org.bouncycastle.jce.provider.BouncyCastleProvider"%>
<%@ page import="org.bouncycastle.jsse.provider.BouncyCastleJsseProvider"%>
<%@ page import="javax.net.ssl.HttpsURLConnection"%>

<%!
/* 1. 본인확인 인증결과 MOKGetToken API 요청 URL */
// private final String MOK_GET_TOKEN_URL = "https://cert-dir.mobile-ok.com/agent/v1/token/get";  // 운영
private final String MOK_GET_TOKEN_URL = "https://scert-dir.mobile-ok.com/agent/v1/token/get";  // 개발

    /* 요청하기 버튼 클릭시 이동 JSP (mobileOK-Request JSP) */
    private final String MOK_REQUEST_JSP = "./mok_api_request.jsp";

    // 이용기관 거래ID생성시 이용기관별 유일성 보장을 위해 설정, 이용기관식별자는 이용기관코드 영문자로 반드시 수정
    private final static String PREFIX_ID = "본인확인 이용기관식별자 PREFIX";  // 8자이내 영대소문자,숫자 (예) MOK, TESTCOKR
%>

<%
    if (Security.getProvider(BouncyCastleProvider.PROVIDER_NAME) == null) {
        Security.addProvider(new BouncyCastleProvider());
        Security.addProvider(new BouncyCastleJsseProvider());
        System.setProperty("jdk.tls.trustNameService", "true");
    }

    mobileOKKeyManager mobileOK = null;
    String mokReuslt = null;
    try {
        /* 2. 본인확인 키파일을 통한 비밀키 설정 */
        mobileOK = new mobileOKKeyManager();
        /* 키파일은 반드시 서버의 안전한 로컬경로에 별도 저장. 웹URL 경로에 파일이 있을경우 키파일이 외부에 노출될 수 있음 주의 */
        mobileOK.keyInit("/본인확인-API 키정보파일 Path/mok_keyInfo.dat", "키파일 패스워드");
        mobileOK.setSiteUrl("본인확인-API 등록 사이트 URL");

        mokReuslt = mobileOK_api_gettoken(mobileOK, request);
    } catch (MobileOKException e) {
        mokReuslt = setErrorMsg(e.getMessage());
    }
%>

<%!
    /* 본인확인-API 토큰요청 예제 함수 */
    public String mobileOK_api_gettoken(mobileOKKeyManager mobileOK, HttpServletRequest request) throws Exception {

        /* 3. 본인확인-API 거래요청정보 생성  */

        /* 3.1 이용기관 거래ID 생성, 20자 이상 40자 이내 이용기관 고유 트랜잭션ID (예시) 이용기관식별자+UUID, ...  */
        // - 본인확인-API 거래ID 는 유일한 값이어야 하며 기 사용한 거래ID가 있는 경우 오류 발생 
        // - 이용기관이 고유식별 ID로 유일성을 보장할 경우 고객이 이용하는 ID사용 가능 
        String sampleClientTxId = PREFIX_ID + UUID.randomUUID().toString().replaceAll("-", "");

        /* 3.2 인증 결과 검증을 위한 거래 ID 세션 저장 */
        // 동일한 세션내 요청과 결과가 동일한지 확인 및 인증결과 재사용 방지처리, 응답결과 처리 시 필수 구현
        // 세션 내 거래ID를 저장하여 검증하는 방법은 권고 사항이며, 이용기관 저장매체(DB 등)에 저장하여 검증 가능
        request.getSession().setAttribute("sessionClientTxId", sampleClientTxId);

        /* 4. 본인확인 토큰요청 데이터 설정 (아래 MOKGetTokenRequestToJsonString() 참조) */
        String MOKGetTokenRequestJsonString = MOKGetTokenRequestToJsonString(
                mobileOK
                , mobileOK.getServiceId() /* 본인확인 서비스 ID */
                , sampleClientTxId        /* 암호화된 이용기관 식별 ID */
                , mobileOK.getSiteUrl()   /* 본인확인-API 등록 사이트 URL */
                ); 

        /* 5. 본인확인 토큰요청 */
        String MOKGetTokenResponseJsonString = sendPost(MOK_GET_TOKEN_URL, MOKGetTokenRequestJsonString);

        /* 6. 본인확인 토큰요청 후 응답 데이터 설정*/
        JSONObject MOKGetTokenResponseJson = new JSONObject(MOKGetTokenResponseJsonString);
        if (!"2000".equals(MOKGetTokenResponseJson.getString("resultCode"))) {
            return MOKGetTokenResponseJson.toString();
        }

        /* 6-1. 본인확인 인증요청 API에서 이용할 데이터 설정 */
        JSONObject MOKAuthRequestData = new JSONObject();
        MOKAuthRequestData.put("encryptMOKToken", MOKGetTokenResponseJson.getString("encryptMOKToken"));
        MOKAuthRequestData.put("publicKey", MOKGetTokenResponseJson.getString("publicKey"));
        MOKAuthRequestData.put("resultCode", MOKGetTokenResponseJson.getString("resultCode"));
        MOKAuthRequestData.put("resultMsg", MOKGetTokenResponseJson.getString("resultMsg"));

        return MOKAuthRequestData.toString();
    }

    /* 본인확인-API 토큰요청 입력데이터 설정 예제 함수 */
    private String MOKGetTokenRequestToJsonString(
            mobileOKKeyManager mobileOK
            , String serviceId
            , String clientTxId
            , String siteUrl) throws MobileOKException {
        Calendar cal = Calendar.getInstance();
        SimpleDateFormat formatter = new SimpleDateFormat("yyyyMMddHHmmss");

        String reqClientInfo = clientTxId + "|" + formatter.format(cal.getTime());

        String encryptReqClientInfo = mobileOK.RSAEncrypt(reqClientInfo);

        JSONObject MOKGettokenRequestJson = new JSONObject();
        MOKGettokenRequestJson.put("serviceId", mobileOK.getServiceId()); 
        MOKGettokenRequestJson.put("encryptReqClientInfo", encryptReqClientInfo);
        MOKGettokenRequestJson.put("siteUrl", mobileOK.getSiteUrl());

        return MOKGettokenRequestJson.toString();
    }


    /* 본인확인 서버 통신 예제 함수 */
    private String sendPost(String dest, String json) throws MobileOKException {
        HttpsURLConnection connection = null; 
        DataOutputStream dataOutputStream = null;
        BufferedReader bufferedReader = null;
        StringBuffer responseData = null;

        try {
            SSLContext sslContext = SSLContext.getInstance("TLSv1.2", new BouncyCastleJsseProvider());
            sslContext.init(null, null, new SecureRandom());

            URL url = new URL(dest);
            connection = (HttpsURLConnection) url.openConnection();
            connection.setSSLSocketFactory(sslContext.getSocketFactory());

            connection.setRequestMethod("POST");
            connection.setRequestProperty("Content-Type", "application/json;charset=UTF-8");
            connection.setDoOutput(true);

            dataOutputStream = new DataOutputStream(connection.getOutputStream());
            dataOutputStream.writeBytes(json.toString());

            bufferedReader = new BufferedReader(
                    new InputStreamReader(connection.getInputStream())
            );
            responseData = new StringBuffer();
            String info;
            while ((info = bufferedReader.readLine()) != null) {
                responseData.append(info);
            }

            return responseData.toString();
        } catch (FileNotFoundException e) {
            throw new MobileOKException("MOK_GET_TOKEN_URL을 확인해 주세요.");
        } catch (JSONException e) {
            e.printStackTrace();
        } catch(IOException e) {
            e.printStackTrace();
        } catch(Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (bufferedReader != null) {
                    bufferedReader.close();
                }

                if (dataOutputStream != null) {
                    dataOutputStream.close();
                }

                if (connection != null) {
                    connection.disconnect();
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

        return null;
    }

    private String setErrorMsg(String errorMsg) {
        JSONObject errorJson = new JSONObject();
        errorJson.put("resultMsg", errorMsg);
        return errorJson.toString();
    }
%>

<html>
<head>
    <meta charset="utf-8"/>
    <title>mok_api_gettoken</title>
    <script>
        const MOKAuthRequestData = <%= mokReuslt  %>
        if (MOKAuthRequestData.resultCode != '2000') {
            /* 오류발생시 */
            window.alert(MOKAuthRequestData.resultCode + ', ' + MOKAuthRequestData.resultMsg);
        } else {
            document.addEventListener("DOMContentLoaded", function () {
                /* 정상작동시 */
                document.getElementById("MOKAuthRequestData").value = JSON.stringify(MOKAuthRequestData);
            });
        }

    </script>
</head>
<body>
<form action=<%= MOK_REQUEST_JSP %> method="post">
    <p>서비스별 인증요청 정보(MOKAuthInfo)를  참고하여 작성</p>
    (공통 필수) <input type="text" required id="serviceType" name="serviceType"  value="" placeholder="telcoAuth" /> 이용상품 코드 (serviceType => "telcoAuth":휴대폰본인확인, telcoAuth-LMS : "휴대폰본인확인 LMS", telcoAuth-ARSAuth : "ARS") <br>
    (공통 필수) <input type="text" required id="providerid" name="providerid" value="" placeholder="SKT" style="left-padding:10px" /> 인증 사업자 구분코드 (providerId => "SKT","KT","LGU","SKTMVNO","KTMVNO","LGUMVNO") <br>
    (공통 필수) <input type="text" required id="reqAuthType" name="reqAuthType" value="" placeholder="PASS" /> 본인확인 인증 처리 Type 코드 (reqAuthType => "SMS" : SMS인증, "PASS" : PASS앱 인증, "ARS" : "ARS") <br>
    (공통 선택) <input type="text" id="usageCode" name="usageCode" value="" placeholder="01001" /> 서비스 이용 코드 (usageCode) <br>
    (공통 필수) <input type="text" id="retTransferType" name="retTransferType" value="MOKResult" /> 요청 대상의 결과 전송 타입 (retTransferType) <br>
    (공통 필수) <input type="text" required id="userName" name="userName" placeholder="홍길동" value="" /> 이름 (userName) <br> 
    (공통 필수) <input type="tel" required id="userPhoneNum" name="userPhoneNum" value="" placeholder="숫자만 (-제외)" /> 핸드폰 번호 (userPhone) <br>
    <input type="tel" id="userBirthday" name="userBirthday" value="" placeholder="20000101" style="width:250px"/> 생년월일(8자리) (userBirthday) <br>
    <input type="text" id="userGender" name="userGender" value="" placeholder="남자 : 1, 여자 : 2" style="width:250px"/> 성별 (userGender => "1" : 남자, "2" : 여자) <br>
    <input type="text" id="userNation" name="userNation" value="" placeholder="내국인 : 0, 외국인 : 1" style="width:250px"/> 내외국인 정보 (userNation => "0" : 내국인, "1" : 외국인) <br>
    <textarea id="sendMsg" name="sendMsg" placeholder="본인확인 인증번호[000000]를 화면에 입력해주세요." style="width:250px"></textarea> SMS 전송 시 사용할 메시지로 사용할 값 (sendMsg)<br>
    <input type="text" id="replyNumber" name="replyNumber" value="" placeholder="15880000" style="width:250px"/> SMS 또는 ARS 전송 시 사용할 송신번호 (replyNumber) <br>
    <input type="text" id="arsCode" name="arsCode" placeholder="ARS-TEST-NVR-11" style="width:250px" /> 운영자와 협의 된 ARS 코드 (arsCode) <br>
    <input type="text" id="arsRequestMsg" name="arsRequestMsg" placeholder='{"companyName":"이용기관명"}' style="width:350px"/> ARS 점유인증 요청시 추가정보 입력 extension/arsRequestMsg <br>
    <input type="submit" style="width:400px; height:30px; margin-top:10px; margin-bottom:10px" value="요청하기"/><br>
    <input type="hidden" id="MOKAuthRequestData" name="MOKAuthRequestData" value=''/>
    <input type="hidden" id="normalFlag" name="normalFlag" value='Y'/>
</form>

</body>
</html>
    mok_api_gettoken.php
      1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
    <?php
    // 각 버전 별 맞는 mobileOKManager-php를 사용
    $mobileOK_path = "./mobileOK_manager_phpseclib_v3.0_v1.0.2.php";

    if(!file_exists($mobileOK_path)) {
        die('1000|mobileOK_Key_Manager파일이 존재하지 않습니다.');
    } else {
        require_once $mobileOK_path;
    }
?>
<?php
    // local시간 설정이 다르게 될  수 있음으로 기본 시간 설정을 서울로 해놓는다.
    date_default_timezone_set('Asia/Seoul');

    session_start();
?>
<?php  
    /* 1. 본인확인 인증결과 MOKGetToken API 요청 URL */
    $MOK_GET_TOKEN_URL = "https://scert-dir.mobile-ok.com/agent/v1/token/get";  // 개발
    // $MOK_GET_TOKEN_URL = "https://cert-dir.mobile-ok.com/agent/v1/token/get";  // 운영

    /* 요청하기 버튼 클릭시 이동 PHP (mobileOK-Request PHP) */
    $MOK_API_REQUEST_PHP = "./mok_api_request.php";

    /* 2. 본인확인 키파일을 통한 비밀키 설정 */
    $mobileOK = new mobileOK_Key_Manager();
    /* 키파일은 반드시 서버의 안전한 로컬경로에 별도 저장. 웹URL 경로에 파일이 있을경우 키파일이 외부에 노출될 수 있음 주의 */
    $key_path = "/본인확인-API 키정보파일 Path/mok_keyInfo.dat";
    $password = "키파일 패스워드";
    $mobileOK->key_init($key_path, $password);
    $mobileOK->set_site_url("본인확인-API 등록 사이트 URL");

    // 이용기관 거래ID생성시 이용기관별 유일성 보장을 위해 설정, 이용기관식별자는 이용기관코드 영문자로 반드시 수정
    $PREFIX_ID = '본인확인 이용기관식별자 PREFIX';  // 8자이내 영대소문자,숫자  (예) MOK, TESTCOKR

    $auth_request_string = mobileOK_api_gettoken($mobileOK, $PREFIX_ID, $MOK_GET_TOKEN_URL);
?>
<?php
    /* 본인확인 API 거래 정보 요청 예제 함수 */
    function mobileOK_api_gettoken ($mobileOK, $PREFIX_ID, $MOK_GET_TOKEN_URL) {
        /* 3. 본인확인-API 거래요청정보 생성  */

        /* 3.1 이용기관 거래ID 생성, 20자 이상 40자 이내 이용기관 고유 트랜잭션ID (예시) 이용기관식별자+UUID, ...  */
        // - 본인확인-API 거래ID 는 유일한 값이어야 하며 기 사용한 거래ID가 있는 경우 오류 발생 
        // - 이용기관이 고유식별 ID로 유일성을 보장할 경우 고객이 이용하는 ID사용 가능 
        $sample_client_tx_id = $PREFIX_ID.uuid();

        /* 3.2 인증 결과 검증을 위한 거래 ID 세션 저장 */
        // 동일한 세션내 요청과 결과가 동일한지 확인 및 인증결과 재사용 방지처리, 응답결과 처리 시 필수 구현
        // 세션 내 거래ID를 저장하여 검증하는 방법은 권고 사항이며, 이용기관 저장매체(DB 등)에 저장하여 검증 가능
        $_SESSION['sessionClientTxId'] = $sample_client_tx_id;

        /* 4. 본인확인 토큰요청 데이터 설정 (아래 MOKGetTokenRequestToJsonString() 참조) */
        $MOK_get_token_request_json_string = MOKGetTokenRequestToJsonString(
            $mobileOK 
            , $mobileOK->get_service_id() /* 본인확인 서비스 ID */
            , $sample_client_tx_id        /* 암호화된 이용기관 식별 ID */
            , $mobileOK->get_site_url()   /* 본인확인-API 등록 사이트 URL */
        );

        /* 5. 본인확인 토큰요청 */
        $MOK_get_token_response_json = sendPost($MOK_get_token_request_json_string, $MOK_GET_TOKEN_URL);

        /* 6. 본인확인 토큰요청 후 응답 데이터 설정*/
        $MOK_get_token_response_array = json_decode($MOK_get_token_response_json);

        /* 6-1. 본인확인 인증요청 API에서 이용할 데이터 설정 */
        $MOK_auth_request_data = array (
            'encryptMOKToken' => $MOK_get_token_response_array->encryptMOKToken
            , 'publicKey' => $MOK_get_token_response_array-> publicKey
            , 'resultCode' => $MOK_get_token_response_array-> resultCode
            , 'resultMsg' => $MOK_get_token_response_array-> resultMsg
        );

        return json_encode($MOK_auth_request_data, JSON_UNESCAPED_SLASHES);
    }

    /* 본인확인-API 토큰요청 입력데이터 설정 예제 함수 */
    function MOKGetTokenRequestToJsonString(
        $mobileOK
        , $service_id
        , $client_tx_id
        , $site_url) {

        $date_time = date("YmdHis");
        $client_tx_id = $client_tx_id."|".$date_time;

        $encrypt_req_client_info = $mobileOK->rsa_encrypt($client_tx_id);

        $MOK_token_request_array = array(
            'serviceId'=>$service_id
            , 'encryptReqClientInfo' => $encrypt_req_client_info
            , 'siteUrl' => $site_url
        );

        return json_encode($MOK_token_request_array, JSON_UNESCAPED_SLASHES);
    }

    /* 본인확인 이용기관 샘플 거래ID(clientTxId(uuid)) 생성 예제 함수 */
    function uuid() {
        return sprintf('%04x%04x%04x%04x%04x%04x%04x%04x',

        // 32 bits for "time_low"
        mt_rand(0, 0xffff), mt_rand(0, 0xffff),

        // 16 bits for "time_mid"
        mt_rand(0, 0xffff),

        // 16 bits for "time_hi_and_version",
        // four most significant bits holds version number 4
        mt_rand(0, 0x0fff) | 0x4000,

        // 16 bits, 8 bits for "clk_seq_hi_res",
        // 8 bits for "clk_seq_low",
        // two most significant bits holds zero and one for variant DCE1.1
        mt_rand(0, 0x3fff) | 0x8000,

        // 48 bits for "node"
        mt_rand(0, 0xffff), mt_rand(0, 0xffff), mt_rand(0, 0xffff)
        );
    }

    /* 본인확인 서버 통신 예제 함수 */
    function sendPost($data, $url) {
        $curl = curl_init();                                                              // curl 초기화
        curl_setopt($curl, CURLOPT_URL, $url);                                            // 데이터를 전송 할 URL
        curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);                                 // 요청결과를 문자열로 반환
        curl_setopt($curl, CURLOPT_HTTPHEADER, array('Content-Type: application/json'));  // 전송 ContentType을 Json형식으로 설정
        curl_setopt($curl, CURLOPT_SSL_VERIFYPEER, false);                                // 원격 서버의 인증서가 유효한지 검사 여부
        curl_setopt($curl, CURLOPT_POSTFIELDS, $data);                                    // POST DATA
        curl_setopt($curl, CURLOPT_POST, true);                                           // POST 전송 여부
        $response = curl_exec($curl);                                                     // 전송
        curl_close($curl);                                                                // 연결해제

        return $response;
    }
?>


<html>
<head>
    <meta charset="utf-8"/>
    <title>mok_api_gettoken</title>
    <script>
        const MOKAuthRequestData = <?php echo $auth_request_string ?>;
        if (MOKAuthRequestData.resultCode != '2000') {
            /* 오류발생시 */
            window.alert(MOKAuthRequestData.resultCode + ', ' + MOKAuthRequestData.resultMsg);
        } else {
            document.addEventListener("DOMContentLoaded", function () {
                /* 정상작동시 */
                document.getElementById("MOKAuthRequestData").value = JSON.stringify(MOKAuthRequestData);

            });
        }

    </script>
</head>
<body>
<form action=<?php echo $MOK_API_REQUEST_PHP ?> method="post">
    <p>이용상품 코드 별 사용자 인증요청 정보 (MOKAuthInfo) 정보를 참고하여 작성</p>
    (공통 필수) <input type="text" required id="serviceType" name="serviceType"  value="" placeholder="telcoAuth" /> 이용상품 코드 (serviceType => "telcoAuth":휴대폰본인확인, telcoAuth-LMS : "휴대폰본인확인 LMS") <br>
    (공통 필수) <input type="text" required id="providerid" name="providerid" value="" placeholder="SKT" style="left-padding:10px" /> 인증 사업자 구분코드 (providerId => "SKT","KT","LGU","SKTMVNO","KTMVNO","LGUMVNO") <br>
    (공통 필수) <input type="text" required id="reqAuthType" name="reqAuthType" value="" placeholder="PASS" /> 본인확인 인증 처리 Type 코드 (reqAuthType => "SMS" : SMS인증, "PASS" : PASS앱 인증) <br>
    (공통 선택) <input type="text" id="usageCode" name="usageCode" value="" placeholder="01001" /> 서비스 이용 코드 (usageCode) <br>
    (공통 필수) <input type="text" id="retTransferType" name="retTransferType" value="MOKResult" /> 요청 대상의 결과 전송 타입 (retTransferType) <br>
    (공통 필수) <input type="text" required id="userName" name="userName" placeholder="홍길동" value="" /> 이름 (userName) <br> 
    (공통 필수) <input type="tel" required id="userPhoneNum" name="userPhoneNum" value="" placeholder="숫자만 (-제외)" /> 핸드폰 번호 (userPhone) <br>
    <input type="text" id="arsCode" name="arsCode" placeholder="ARS-TEST-NVR-11" style="width:250px" /> 운영자와 협의 된 ARS 코드 (arsCode) <br>
    <input type="tel" id="userBirthday" name="userBirthday" value="" placeholder="20000101" style="width:250px"/> 생년월일(8자리) (userBirthday) <br>
    <input type="text" id="userGender" name="userGender" value="" placeholder="남자 : 1, 여자 : 2" style="width:250px"/> 성별 (userGender => "1" : 남자, "2" : 여자) <br>
    <input type="text" id="userNation" name="userNation" value="" placeholder="내국인 : 0, 외국인 : 1" style="width:250px"/> 내외국인 정보 (userNation => "0" : 내국인, "1" : 외국인) <br>
    <textarea id="sendMsg" name="sendMsg" placeholder="[드림시큐리티] 인증번호 [000000]" style="width:250px"></textarea> SMS 전송 시 사용할 메시지로 사용할 값 (sendMsg)<br>
    <input type="text" id="replyNumber" name="replyNumber" value="" placeholder="15880000" style="width:250px"/> SMS 또는 ARS 전송 시 사용할 송신번호 (replyNumber) <br>
    <input type="text" id="arsRequestMsg" name="arsRequestMsg" placeholder='{"companyName":"이용기관명"}' style="width:350px"/> ARS 점유인증 요청시 추가정보 입력 extension/arsRequestMsg <br>
    <input type="submit" style="width:400px; height:30px; margin-top:10px; margin-bottom:10px" value="요청하기"/><br>

    <input type="hidden" id="MOKAuthRequestData" name="MOKAuthRequestData" value=''/>
    <input type="hidden" id="normalFlag" name="normalFlag" value='Y'/>
</form>

</body>
</html>
    mok_api_server.js
      1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
    const express = require('express');
const session = require('express-session');
const axios = require('axios');
const bodyParser = require('body-parser');

/* 암호화 라이브러리 mok_Key_Manager */
let mobileOK;
try {
    mobileOK= require("./mok_Key_Manager_v1.0.3.js");
} catch (error)  {
    console.log('mok_Key_Manager 파일의 경로가 올바르지 않습니다.');
}

/* 1. express 서버 설정 */
const app = express();

/* 1-1 포트(port) 설정 */
const port = 8080;

/* 1-2 루트(root)패키지의 정적파일을 읽기위한 설정 */
app.use(express.static('./'));

/* 1-3 Content-type : application/json 설정 */
app.use(bodyParser.json())

/* 1-4 request-body 데이터 urlencode 설정 */
app.use(bodyParser.urlencoded({ extended: true }));

/* 1-5 session 설정 */
app.use(session({
    secret:uuid(),
    resave:false,
    saveUninitialized: false
}));

/* 2. 본인확인 인증결과 경로설정 */
/* 2-1 본인확인 Node.js서버 매핑 URL */
const getTokenUri = '/mok_api_gettoken';   // mok_api_gettoken 매핑 URI
const requestUri = '/mok_api_request';     // mok_api_request 매핑 URI
const resultUri = '/mok_api_result';       // mok_api_result 매핑 URI
const callUri = '/mok_ars_call';       // mok_ars_call 매핑 URI

/* 2-2 본인확인 뷰(view) 경로 설정 */
const getTokenEjs = 'mok_api_gettoken.ejs';  // mok_api_gettoken.ejs의 경로
const requestEjs = 'mok_api_request.ejs';     // mok_api_request.ejs의 경로
const resultEjs = 'mok_api_result.ejs';        // mok_api_result.ejs의 경로
const callEjs = 'mok_ars_call.ejs';        // mok_ars_call.ejs의 경로
/* 2-2 본인확인 요청 경로 설정 */
/* 2-2-1 본인확인 거래토큰요청(MOKGetToken API) 경로 설정 */
const MOK_GET_TOKEN_URL = 'https://scert-dir.mobile-ok.com/agent/v1/token/get';        // 개발
// const MOK_GET_TOKEN_URL = 'https://cert-dir.mobile-ok.com/agent/v1/token/get';      // 운영

/* 2-2-2 본인확인 인증요청(MOKAuth API) 경로 설정 */
const MOK_REQUEST_URL = 'https://scert-dir.mobile-ok.com/agent/v1/auth/request';       // 개발
// const MOK_REQUEST_URL = 'https://cert-dir.mobile-ok.com/agent/v1/auth/request';     // 운영
const MOK_RESEND_URL = 'https://scert-dir.mobile-ok.com/agent/v1/auth/resend';         // 개발
// const MOK_RESEND_URL = 'https://cert-dir.mobile-ok.com/agent/v1/auth/resend';       // 운영

/* 2-2-3 본인확인 검증요청(MOKConfirm API) 경로 설정 */
const MOK_CONFIRM_URL = "https://scert-dir.mobile-ok.com/agent/v1/confirm/request";    // 개발
// const MOK_CONFIRM_URL = "https://cert-dir.mobile-ok.com/agent/v1/confirm/request";  // 운영

/* 2-2-4 본인확인 콜요청(MOKCall API) 경로 설정 */
const MOK_CALL_URL = "https://scert-dir.mobile-ok.com/agent/v1/auth/call";    // 개발
// const MOK_CONFIRM_URL = "https://cert-dir.mobile-ok.com/agent/v1/confirm/request";  // 운영

/* 3. 본인확인 서비스 초기화 설정 */
/* 키파일은 반드시 서버의 안전한 로컬경로에 별도 저장. 웹URL 경로에 파일이 있을경우 키파일이 외부에 노출될 수 있음 주의 */
const keyPath = '/본인확인-API 키정보파일 Path/mok_keyInfo.dat';
const password = '키파일 패스워드';
mobileOK.keyInit(keyPath, password);
mobileOK.setSiteUrl('본인확인-API 등록 사이트 URL');

// 이용기관 거래ID생성시 이용기관별 유일성 보장을 위해 설정, 이용기관식별자는 이용기관코드 영문자로 반드시 수정
const PREFIX_ID = "본인확인 이용기관식별자 PREFIX";  //  8자이내 영대소문자,숫자 (예) MOK, TESTCOKR

/* 본인확인-API 토큰요청 예제 함수 */
app.get(getTokenUri, async (req, res) => {
    /* 1. 본인확인-API 거래요청정보 생성  */

    /* 1.1 이용기관 거래ID 생성, 20자 이상 40자 이내 이용기관 고유 트랜잭션ID (예시) 이용기관식별자+UUID, ...  */
    // - 본인확인-API 거래ID 는 유일한 값이어야 하며 기 사용한 거래ID가 있는 경우 오류 발생 
    // - 이용기관이 고유식별 ID로 유일성을 보장할 경우 고객이 이용하는 ID사용 가능 
    let sampleClientTxId = PREFIX_ID + uuid();

    /* 1.2 인증 결과 검증을 위한 거래 ID 세션 저장 */
    // 동일한 세션내 요청과 결과가 동일한지 확인 및 인증결과 재사용 방지처리, 응답결과 처리 시 필수 구현
    // 세션 내 거래ID를 저장하여 검증하는 방법은 권고 사항이며, 이용기관 저장매체(DB 등)에 저장하여 검증 가능
    req.session.clientTxId = sampleClientTxId;

    /* 2. 본인확인 토큰요청 데이터 설정 (아래 MOKGetTokenRequestToJsonString() 참조) */
    const MOKGetTokenRequestJsonString = MOKGetTokenRequestToJsonString(
        mobileOK
        , sampleClientTxId
        , mobileOK.getServiceId()
        , mobileOK.getSiteUrl()
    );

    /* 3. 본인확인 토큰요청 */
    const gettokenResponseObject = await sendPost(MOK_GET_TOKEN_URL, MOKGetTokenRequestJsonString);

    /* 4. 본인확인 토큰요청 후 응답 데이터 설정*/
    /* 4-1. 본인확인 인증요청 API에서 이용할 데이터 설정 */
    MOKAuthRequestData = {
        "encryptMOKToken" : gettokenResponseObject.encryptMOKToken
        , "publicKey" : gettokenResponseObject.publicKey
    }
    MOKAuthRequestData = JSON.stringify(MOKAuthRequestData)

    res.render(getTokenEjs, {
        MOKAuthRequestData : MOKAuthRequestData
        , "resultCode" : gettokenResponseObject.resultCode
        , "resultMsg" : gettokenResponseObject.resultMsg
        , "requestUri" : requestUri
    });
});

/* 본인확인-API 토큰요청 입력데이터 설정 예제 함수 */
function MOKGetTokenRequestToJsonString(mobileOK, clientTxId, serviceId, siteUrl) {
    clientTxId = clientTxId + "|" + getCurrentDate();
    const encClientTxId = mobileOK.RSAEncrypt(clientTxId);

    const gettokenRequestObject = {
        'serviceId' : serviceId
        , 'encryptReqClientInfo' : encClientTxId
        , 'siteUrl' : siteUrl
    };

    return gettokenRequestObject;
}


/* 본인확인-API 인증요청/재요청 예제 함수 */
app.post(requestUri, async (req, res) => {

    /* 각 버튼 클릭시 이동 URL 설정 */
    const reqUrl = {
        /* 취소버튼 클릭시 이동 URL */
        MOKGetTokenUri : getTokenUri
        /* 확인버튼 클릭시 이동 URL */
        , MOKConfirmUri : resultUri
        /* 재전송버튼 클릭시 이동 URL */
        , MOKResendUri : requestUri
        /* 재전송버튼 클릭시 이동 URL */
        , MOKCallUri : callUri
    }

    /* 1. 현재 페이지의 요청 정보 (정상요청 / 재전송 요청 / 검증재시도 / 비정상적인 요청)에 따른 실행 */
    if (req.body.hasOwnProperty('normalFlag')) {
        console.log('정상요청 (MOKAuth Request)');

        try {
            res.render(requestEjs, await mobileOK_api_auth_request(req.body, reqUrl));
        } catch (MOKException) {
            res.render(resultEjs, {
                getTokenUri : getTokenUri
                , data : {
                    resultMsg : '본인확인 서버통신(인증요청)에 실패했습니다.'
                }
            });
        }
    } else if (req.body.hasOwnProperty('MOKAuthResendData')) {
        console.log('재요청 (MOKResend Request)');

        try {
            res.render(requestEjs, await mobileOK_api_auth_resend(req.body.MOKAuthResendData, reqUrl));
        } catch (MOKException) {
            res.render(resultEjs, {
                getTokenUri : getTokenUri
                , data : {
                    resultMsg : '본인확인 서버통신(인증 재요청)에 실패했습니다.'
                }
            });
        }
    } else if (req.body.hasOwnProperty('MOKConfirmRetryData')
        && req.body.MOKConfirmRetryData != '') {
        console.log('검증 재시도 (MOKConfirm Retry)');

        let MOKConfirmRetryData = req.body.MOKConfirmRetryData;
        MOKConfirmRetryData = JSON.parse(MOKConfirmRetryData);
        MOKConfirmRetryData.resultCode = "2000";

        res.render(requestEjs, {
            MOKConfirmData : JSON.stringify(MOKConfirmRetryData)
            , reqUrl : reqUrl
        })
    } else {
        res.render(requestEjs, {
            resultMsg : '올바르지 않는 인증 사업자 구분코드 또는 본인확인 인증 처리 Type 입니다.'
        })
    }

})

/* 본인확인-API 인증요청 예제 함수 */
async function mobileOK_api_auth_request(reqBody, reqUrl) {
    const MOKAuthRequestData = JSON.parse(reqBody.MOKAuthRequestData);

    /* 1. 본인확인 인증요청 입력정보 설정 (아래 MOKAuthInfoToJson() 참조) */
    let MOKAuthRequestJsonString;
    if ('PASS' == reqBody.reqAuthType) {
        MOKAuthRequestJsonString = MOKAuthRequestToJsonString(
            mobileOK
            , MOKAuthRequestData.publicKey       /* MOK_API_Gettoken 응답으로 받은 publicKey */
            , MOKAuthRequestData.encryptMOKToken /* MOK_API_Gettoken 응답으로 받은 encryptMOKToken */
            , mobileOK.getSiteUrl()   /* 본인확인-API 등록 사이트 URL */
            , reqBody.providerid      /* 인증 사업자 구분코드 */
            , reqBody.reqAuthType     /* 본인확인 인증 처리 Type 코드 */
            , reqBody.usageCode       /* 서비스 이용 코드 */
            , reqBody.serviceType     /* 이용상품 코드 */
            , reqBody.userName        /* 사용자 이름 */
            , reqBody.userPhoneNum    /* 사용자 전화번호 */
            , reqBody.retTransferType /* 요청 대상의 결과 전송 타입 */
            , ''                      /* 운영자와 협의 된 ARS 코드 */
            , ''                      /* 사용자 생년월일 */
            , ''                      /* 사용자 성별 */
            , ''                      /* 사용자 내외국인 정보 */
            , ''                      /* SMS 발송내용 또는 LMS 발송내용 */
            , ''                      /* SMS 또는 ARS 전송 시 사용할 송신번호 */
            , ''                      /* 이용기관별 추가정보 전달처리시 이용 JSON Object */
        );
    } else if ('telcoAuth-ARSAuth' == reqBody.serviceType) {
        var extension = {};
        extension.arsRequestMsg = reqBody.arsRequestMsg;

        MOKAuthRequestJsonString = MOKAuthRequestToJsonString(
            mobileOK
            , MOKAuthRequestData.publicKey       /* MOK_API_Gettoken 응답으로 받은 publicKey */
            , MOKAuthRequestData.encryptMOKToken /* MOK_API_Gettoken 응답으로 받은 encryptMOKToken */
            , mobileOK.getSiteUrl()   /* 본인확인-API 등록 사이트 URL */
            , reqBody.providerid      /* 인증 사업자 구분코드 */
            , reqBody.reqAuthType     /* 본인확인 인증 처리 Type 코드 */
            , reqBody.usageCode       /* 서비스 이용 코드 */
            , reqBody.serviceType     /* 이용상품 코드 */
            , reqBody.userName        /* 사용자 이름 */
            , reqBody.userPhoneNum    /* 사용자 전화번호 */
            , reqBody.retTransferType /* 요청 대상의 결과 전송 타입 */
            , reqBody.arsCode         /* 운영자와 협의 된 ARS 코드 */
            , reqBody.userBirthday    /* 사용자 생년월일 */
            , reqBody.userGender      /* 사용자 성별 */
            , reqBody.userNation      /* 사용자 내외국인 정보 */
            , reqBody.sendMsg         /* SMS 발송내용 또는 LMS 발송내용 */
            , reqBody.replyNumber     /* SMS 또는 ARS 전송 시 사용할 송신번호 */
            , extension               /* 이용기관별 추가정보 전달처리시 이용 JSON Object */
        );
    } else if (reqBody.serviceType.indexOf('telcoAuth') != -1
        && 'SMS' == reqBody.reqAuthType
        || 'LMS' == reqBody.reqAuthType) {
        MOKAuthRequestJsonString = MOKAuthRequestToJsonString(
            mobileOK
            , MOKAuthRequestData.publicKey       /* MOK_API_Gettoken 응답으로 받은 publicKey */
            , MOKAuthRequestData.encryptMOKToken /* MOK_API_Gettoken 응답으로 받은 encryptMOKToken */
            , mobileOK.getSiteUrl()   /* 본인확인-API 등록 사이트 URL */
            , reqBody.providerid      /* 인증 사업자 구분코드 */
            , reqBody.reqAuthType     /* 본인확인 인증 처리 Type 코드 */
            , reqBody.usageCode       /* 서비스 이용 코드 */
            , reqBody.serviceType     /* 이용상품 코드 */
            , reqBody.userName        /* 사용자 이름 */
            , reqBody.userPhoneNum    /* 사용자 전화번호 */
            , reqBody.retTransferType /* 응답 URL 주소 */
            , ''                      /* 운영자와 협의 된 ARS 코드 */
            , reqBody.userBirthday    /* 사용자 생년월일 */
            , reqBody.userGender      /* 사용자 성별 */
            , reqBody.userNation      /* 사용자 내외국인 정보 */
            , reqBody.sendMsg         /* SMS 발송내용 또는 LMS 발송내용 */
            , reqBody.replyNumber     /* SMS 또는 ARS 전송 시 사용할 송신번호 */
            , ''                      /* 이용기관별 추가정보 전달처리시 이용 JSON Object */
        );
    } else if ('SMSAuth' == reqBody.serviceType) {
        MOKAuthRequestJsonString = MOKAuthRequestToJsonString(
            mobileOK
            , MOKAuthRequestData.publicKey       /* MOK_API_Gettoken 응답으로 받은 publicKey */
            , MOKAuthRequestData.encryptMOKToken /* MOK_API_Gettoken 응답으로 받은 encryptMOKToken */
            , mobileOK.getSiteUrl()   /* 본인확인-API 등록 사이트 URL */
            , reqBody.providerid      /* 인증 사업자 구분코드 */
            , reqBody.reqAuthType     /* 본인확인 인증 처리 Type 코드 */
            , reqBody.usageCode       /* 서비스 이용 코드 */
            , reqBody.serviceType     /* 이용상품 코드 */
            , reqBody.userName        /* 사용자 이름 */
            , reqBody.userPhoneNum    /* 사용자 전화번호 */
            , reqBody.retTransferType /* 응답 URL 주소 */
            , ''                      /* 운영자와 협의 된 ARS 코드 */
            , ''                      /* 사용자 생년월일 */
            , ''                      /* 사용자 성별 */
            , ''                      /* 사용자 내외국인 정보 */
            , reqBody.sendMsg         /* SMS 발송내용 또는 LMS 발송내용 */
            , reqBody.replyNumber     /* SMS 또는 ARS 전송 시 사용할 송신번호 */
            , ''                      /* 이용기관별 추가정보 전달처리시 이용 JSON Object */
        );
    }

    /* 2. 본인확인 인증요청 */
    const MOKAuthResponseObject = await sendPost(MOK_REQUEST_URL, MOKAuthRequestJsonString);

    /* 3. 본인확인 인증요청 실패시 */
    if (MOKAuthResponseObject.resultCode != '2000') {
        return {
            MOKConfirmData : JSON.stringify({
                resultCode : MOKAuthResponseObject.resultCode
                , resultMsg : MOKAuthResponseObject.resultMsg
            })
            , reqUrl : reqUrl
        };
    }

    var MOKConfirmData = null;

    /* 4. 본인확인 검증요청 API에서 이용할 데이터 설정 */
    if ('telcoAuth-ARSAuth' == reqBody.serviceType) {
        MOKConfirmData = {
            encryptMOKToken : MOKAuthResponseObject.encryptMOKToken
            , publicKey : MOKAuthRequestData.publicKey
            , resultCode : MOKAuthResponseObject.resultCode
            , resultMsg : MOKAuthResponseObject.resultMsg
            , arsOtpNumber : MOKAuthResponseObject.arsOtpNumber
        }
    } else {
        MOKConfirmData = {
            encryptMOKToken : MOKAuthResponseObject.encryptMOKToken
            , publicKey : MOKAuthRequestData.publicKey
            , resultCode : MOKAuthResponseObject.resultCode
            , resultMsg : MOKAuthResponseObject.resultMsg
            , arsOtpNumber : ''
        }
    }

    /* 5. 본인확인 인증요청정보 반환 */
    return {
        MOKConfirmData : JSON.stringify(MOKConfirmData)
        , reqUrl : reqUrl
    }
}

/* 본인확인-API 인증재요청 예제 함수 */
async function mobileOK_api_auth_resend(MOKAuthResendData, reqUrl) {
    MOKAuthResendData = JSON.parse(MOKAuthResendData);

    /* 1. 본인확인 재전송 요청 입력정보 설정 */
    const MOKAuthResendRequestObject = {
        'encryptMOKToken' : MOKAuthResendData.encryptMOKToken
    }

    /* 2. 본인확인 재전송 요청 */
    const MOKAuthResendResponseObject = await sendPost(MOK_RESEND_URL, MOKAuthResendRequestObject);

    /* 3. 본인확인 재전송 실패시 */
    if (MOKAuthResendResponseObject.resultCode != '2000') {
        return {
            MOKConfirmData : JSON.stringify({
                resultCode : MOKAuthResendResponseObject.resultCode
                , resultMsg : MOKAuthResendResponseObject.resultMsg
            })
            , reqUrl : reqUrl
        };
    }

    /* 4 본인확인 결과요청 입력 정보 설정 */
    const MOKConfirmData = {
        encryptMOKToken : MOKAuthResendResponseObject.encryptMOKToken
        , publicKey : MOKAuthResendData.publicKey
        , resultCode : MOKAuthResendResponseObject.resultCode
        , resultMsg : MOKAuthResendResponseObject.resultMsg
    }

    /* 5. 본인확인 재인증요청정보 반환 */
    return {
        MOKConfirmData : JSON.stringify(MOKConfirmData)
        , reqUrl : reqUrl
    }
}

/* 본인확인-API 인증요청 정보 */
function MOKAuthRequestToJsonString(
    mobileOK
    , publicKey
    , encryptMOKToken
    , siteUrl
    , providerId
    , reqAuthType
    , usageCode
    , serviceType
    , userName
    , userPhoneNum
    , retTransferType
    , arsCode
    , userBirthday
    , userGender
    , userNation
    , sendMsg
    , replyNumber
    , extension
) {
    let encryptDataObject = {
        reqAuthType : reqAuthType
        , providerId : providerId
        , usageCode : usageCode
        , serviceType : serviceType
        , retTransferType : retTransferType
        , userName  : userName
        , userPhone : userPhoneNum
    };
    if ('telcoAuth-ARSAuth' == serviceType) {
        encryptDataObject.arsCode = arsCode;
        encryptDataObject.userBirthday = userBirthday;
        encryptDataObject.userGender = userGender;
        encryptDataObject.userNation = userNation;
        encryptDataObject.replyNumber = replyNumber;
        encryptDataObject.extension = extension;
    } else if (serviceType.indexOf('telcoAuth') != -1
        && 'SMS' == reqAuthType
        || 'LMS' == reqAuthType) {
        encryptDataObject.userBirthday = userBirthday;
        encryptDataObject.userGender = userGender;
        encryptDataObject.userNation = userNation;
        if (sendMsg != '') {
            encryptDataObject.sendMsg = sendMsg;
        }
        if (replyNumber != '') {
            encryptDataObject.replyNumber = replyNumber;
        }
    } else if ('SMSAuth' == serviceType) {
        if (sendMsg != '') {
            encryptDataObject.sendMsg = sendMsg;
        }
        if (replyNumber != '') {
            encryptDataObject.replyNumber = replyNumber;
        }
    }

    encryptMOKAuthInfo = mobileOK.RSAServerEncrypt(publicKey, JSON.stringify(encryptDataObject));

    MOKAuthRequestJson = {
        siteUrl : siteUrl
        , encryptMOKToken : encryptMOKToken
        , encryptMOKAuthInfo : encryptMOKAuthInfo
    }

    return MOKAuthRequestJson;
}

/* 본인확인 API 콜요청 예제 함수 */
app.post(callUri, async (req, res) => {

    const reqUrl = {
        /* 검증 버튼 클릭시 이동 URL */
        MOKConfirmUri : resultUri
        /* 취소 버튼 클릭시 이동 URL */
        , MOKGetTokenUri : getTokenUri
        /* 재시도 버튼 클릭시 이동 URL */
        , MOKCallUri : callUri
    }

    if(!(req.body.MOKCallData == null || req.body.MOKCallData == "")) {
        let MOKCallData = decodeURIComponent(req.body.MOKCallData);

        MOKCallData = JSON.parse(MOKCallData);

        MOKCallRequest = MOKCallToJsonString(MOKCallData.encryptMOKToken);

        const callResponseObject = await sendPost(MOK_CALL_URL, MOKCallRequest);

        if (callResponseObject.resultCode != '2000') {
            MOKConfirmFailData = {};

            MOKConfirmFailData["resultCode"] = callResponseObject.resultCode;
            MOKConfirmFailData["resultMsg"] = callResponseObject.resultMsg;

            res.render(callEjs, {
                resultData : JSON.stringify(MOKConfirmFailData)
                , reqUrl : reqUrl
            });
        } else {
            MOKConfirmSuccessData = {};

            MOKConfirmSuccessData["resultCode"] = callResponseObject.resultCode;
            MOKConfirmSuccessData["resultMsg"] = callResponseObject.resultMsg;
            MOKConfirmSuccessData["encryptMOKToken"] = callResponseObject.encryptMOKToken;
            MOKConfirmSuccessData["publicKey"] = MOKCallData.publicKey;
            MOKConfirmSuccessData["arsOtpNumber"] = MOKCallData.arsOtpNumber;

            res.render(callEjs, {
                resultData : JSON.stringify(MOKConfirmSuccessData)
                , reqUrl : reqUrl
            });
        }
    } else if(!(req.body.encryptMOKToken == null || req.body.encryptMOKToken == "")) {
        MOKCallRequest = MOKCallToJsonString(req.body.encryptMOKToken);

        const callResponseObject = await sendPost(MOK_CALL_URL, MOKCallRequest);

        if (callResponseObject.resultCode != '2000') {
            MOKConfirmFailData = {};

            MOKConfirmFailData["resultCode"] = callResponseObject.resultCode;
            MOKConfirmFailData["resultMsg"] = callResponseObject.resultMsg;

            res.render(callEjs, {
                resultData : JSON.stringify(MOKConfirmFailData)
                , reqUrl : reqUrl
            });
        } else {
            MOKConfirmSuccessData = {};

            MOKConfirmSuccessData["resultCode"] = callResponseObject.resultCode;
            MOKConfirmSuccessData["resultMsg"] = callResponseObject.resultMsg;
            MOKConfirmSuccessData["encryptMOKToken"] = callResponseObject.encryptMOKToken;
            MOKConfirmSuccessData["publicKey"] = req.body.publicKey;
            MOKConfirmSuccessData["arsOtpNumber"] = req.body.arsOtpNumber;

            res.render(callEjs, {
                resultData : JSON.stringify(MOKConfirmSuccessData)
                , reqUrl : reqUrl
            });
        }
    }
})

/* 본인확인-API 인증요청 정보 */
function MOKCallToJsonString(
    encryptMOKToken
) {

    MOKAuthCallJson = {
        encryptMOKToken : encryptMOKToken
    }

    return MOKAuthCallJson;
}

/* 본인확인 API 검증요청 예제 함수 */
app.post(resultUri, async (req, res) => {

    const reqUrl = {
        /* 처음페이지 버튼 클릭시 이동 URL */
        MOKGetTokenUri : getTokenUri
        /* 재시도 버튼 클릭시 이동 URL */
        , MOKRequestUri : requestUri
    }

    let MOKConfirmData = req.body.MOKConfirmData;
    MOKConfirmData = JSON.parse(decodeURIComponent(MOKConfirmData));

    if (!MOKConfirmData.hasOwnProperty("encryptMOKToken")) {
        return res.render(resultEjs, {
            data : {
                resultMsg : "-1|본인확인 요청 MOKToken이 없습니다."
            }
            , reqUrl : reqUrl
        });
    }

    /* 1. 본인확인 검증요청 입력정보 설정 (아래 MOKConfirmRequestToJsonString() 참조) */
    let confirmRequestObject = "";
    if (!req.body.authNumber) {
        confirmRequestObject = MOKConfirmRequestToJsonString(
            mobileOK
            , MOKConfirmData.encryptMOKToken
            , ""
            , ""
        );
    } else if ("" != req.body.authNumber
        && null != req.body.authNumber) {
        confirmRequestObject = MOKConfirmRequestToJsonString(
            mobileOK
            , MOKConfirmData.encryptMOKToken
            , MOKConfirmData.publicKey
            , req.body.authNumber
        );
    }

    /* 2. 본인확인 인증결과 확인 요청 */
    const confirmResponseObject = await sendPost(MOK_CONFIRM_URL, confirmRequestObject);

    /* 2.1 본인확인 검증요청 실패시 */
    if (confirmResponseObject.resultCode != '2000') {
        const MOKConfirmRetryData = {
            encryptMOKToken : confirmResponseObject.encryptMOKToken
            , publicKey : MOKConfirmData.publicKey
        }

        return res.render(resultEjs, {
            data : {
                resultCode : confirmResponseObject.resultCode
                , resultMsg : confirmResponseObject.resultMsg
            }
            , MOKConfirmRetryDataJson : JSON.stringify(MOKConfirmRetryData)
            , reqUrl : reqUrl
        });
    }

    /* 3. 본인확인 결과 JSON 정보 복호화 */
    let decrpytResultObject;
    try {
        let encryptMOKResult = confirmResponseObject.encryptMOKResult;

        /* 3.1. 본인확인 인증결과 응답 암호화데이터 복호화 */
        const decryptMOKResultJson = mobileOK.getResult(encryptMOKResult);
        decrpytResultObject = JSON.parse(decryptMOKResultJson);
    } catch(error) {
        return res.render(resultEjs, {
            reqUrl : reqUrl
            , data : {
                resultCode : '-3'
                , resultMsg : '본인확인 결과 복호화 오류'
            }
        });
    }

    /* 4. 본인확인 인증결과 반환데이터 설정 */

    /* 이용기관 거래 ID */
    let clientTxId = '';
    if (decrpytResultObject.hasOwnProperty("clientTxId")) {
        clientTxId = decrpytResultObject.clientTxId;
    }

    // 세션 내 요청 clientTxId 와 수신한 clientTxId 가 동일한지 반드시 비교
    if (req.session.clientTxId != clientTxId) {
        return res.send('-4|세션값에 저장된 거래ID 비교 실패');
    }

    /* 사용자 이름 */
    let userName = '';
    if (decrpytResultObject.hasOwnProperty("userName")) {
        userName = decrpytResultObject.userName;
    }
    /* 이용기관 ID */
    let siteId = '';
    if (decrpytResultObject.hasOwnProperty("siteId")) {
        siteId = decrpytResultObject.siteId;
    }
    /* 본인확인 거래 ID */
    let txId = '';
    if (decrpytResultObject.hasOwnProperty("txId")) {
        txId = decrpytResultObject.txId;
    }
    /* 서비스제공자(인증사업자) ID */
    let providerId = '';
    if (decrpytResultObject.hasOwnProperty("providerId")) {
        providerId = decrpytResultObject.providerId;
    }
    /* 이용 서비스 유형 */
    let serviceType = '';
    if (decrpytResultObject.hasOwnProperty("serviceType")) {
        serviceType = decrpytResultObject.serviceType;
    }
    /* 사용자 CI */
    let ci = '';
    if (decrpytResultObject.hasOwnProperty("ci")) {
        ci = decrpytResultObject.ci;
    }
    /* 사용자 DI */
    let di = '';
    if (decrpytResultObject.hasOwnProperty("di")) {
        di = decrpytResultObject.di;
    }
    /* 사용자 전화번호 */
    let userPhone = '';
    if (decrpytResultObject.hasOwnProperty("userPhone")) {
        userPhone = decrpytResultObject.userPhone;
    }
    /* 사용자 생년월일 */
    let userBirthday = '';
    if (decrpytResultObject.hasOwnProperty("userBirthday")) {
        userBirthday = decrpytResultObject.userBirthday;
    }
    /* 사용자 성별 (1: 남자, 2: 여자) */
    let userGender = '';
    if (decrpytResultObject.hasOwnProperty("userGender")) {
        userGender = decrpytResultObject.userGender;
    }
    /* 사용자 국적 (0: 내국인, 1: 외국인) */
    let userNation = '';
    if (decrpytResultObject.hasOwnProperty("userNation")) {
        userNation = decrpytResultObject.userNation;
    }
    /* 성인 인증 결과 (Y: 성인, N: 미성년자) SMS 성인여부 요청 시 응답 값이 존재*/
    let isAdult = '';
    if (decrpytResultObject.hasOwnProperty("isAdult")) {
        isAdult = decrpytResultObject.isAdult;
    }
    /* 본인확인 인증 종류 */
    const reqAuthType = decrpytResultObject.reqAuthType;
    /* 본인확인 요청 시간 */
    const reqDate = decrpytResultObject.reqDate;
    /* 본인확인 인증 서버 */
    const issuer = decrpytResultObject.issuer;
    /* 본인확인 인증 시간 */
    const issueDate = decrpytResultObject.issueDate;

    /* 5. 이용기관 응답데이터 셔션 및 검증유효시간 처리  */

    // 검증정보 유효시간 검증 (검증결과 생성 후 10분 이내 검증 권고)
    let oldDate = new Date(issueDate);
    oldDate = getOldTime(oldDate);
    const currentDate = getCurrentDate();
    if (oldDate < currentDate) {
        return res.send('-5|토큰 생성 10분 결과');
    }

    /* 6. 이용기관 서비스 기능 처리 */

    // - 이용기관에서 수신한 개인정보 검증 확인 처리

    // - 이용기관에서 수신한 CI 확인 처리

    /* 7. 본인확인 결과 응답 */

    // 복호화된 개인정보는 DB보관 또는 세션보관하여 개인정보 저장시 본인확인에서 획득한 정보로 저장하도록 처리 필요
    // 개인정보를 웹브라우져에 전달할 경우 외부 해킹에 의해 유출되지 않도록 보안처리 필요
    res.render(resultEjs, {
        data : {
            resultCode : confirmResponseObject.resultCode
            , resultMsg : confirmResponseObject.resultMsg
            , userName : userName
        }
        , reqUrl : reqUrl
    });
})

/* 본인확인-API 검증요청 정보 */
function MOKConfirmRequestToJsonString(mobileOK, encryptMOKToken, publicKey, authNumber) {
    MOKconfirmRequestJson = {
        encryptMOKToken : encryptMOKToken
    }

    if (authNumber) {
        authNumber = {
            authNumber : authNumber
        }

        const encAuthNumber = mobileOK.RSAServerEncrypt(publicKey, JSON.stringify(authNumber));

        MOKconfirmRequestJson.encryptMOKVerifyInfo = encAuthNumber;
    }

    return MOKconfirmRequestJson;
}

/* 본인확인 이용기관 샘플 거래ID(clientTxId(uuid)) 생성 예제 함수 */
function uuid() {
    return 'xxxxxxxxxxxx4xxxyxxxxxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
        var r = Math.random() * 16 | 0, v = c == 'x' ? r : (r & 0x3 | 0x8);

        return v.toString(16);
    });
}

/* 본인확인 이용기관 거래ID(clientTxId(요청 시간)) 생성 예제 함수 */
function getCurrentDate() {
    let newDate = new Date();
    newDate.toLocaleString('ko-kr');

    let year = newDate.getFullYear();
    let mon = newDate.getMonth() + 1;
    let date = newDate.getDate();

    let hour = newDate.getHours();
    let min = newDate.getMinutes();
    let sec = newDate.getSeconds();

    mon = mon < 10 ? `0${mon}` : `${mon}`;
    date = date < 10 ? `0${date}` : `${date}`;
    hour = hour < 10 ? `0${hour}` : `${hour}`;
    min = min < 10 ? `0${min}` : `${min}`;
    sec = sec < 10 ? `0${sec}` : `${sec}`;

    const reqDate = year + mon + date + hour + min + sec;

    return reqDate;
}

function getOldTime(oldTime) {
    let year = oldTime.getFullYear();
    let mon = oldTime.getMonth() + 1;
    let date = oldTime.getDate();

    let hour = oldTime.getHours();
    let min = oldTime.getMinutes()+ 10;
    let sec = oldTime.getSeconds();

    if (min >= 60) {
        min = min - 60;

        hour = hour + 1;
    }
    if (hour >= 24) {
        hour = hour - 24;

        date = date + 1;
    }
    if (date > new Date(year, mon, 0).getDate()) {
        date = date - (new Date(year, mon, 0).getDate());

        mon = mon + 1;
    }
    if (mon >= 13) {
        mon = mon - 12;

        year = year + 1;
    }

    mon = mon < 10 ? `0${mon}` : `${mon}`;
    date = date < 10 ? `0${date}` : `${date}`;
    hour = hour < 10 ? `0${hour}` : `${hour}`;
    min = min < 10 ? `0${min}` : `${min}`;
    sec = sec < 10 ? `0${sec}` : `${sec}`;

    const reqDate = year + mon + date + hour + min + sec;

    return reqDate;
}

/* 본인확인 서버 통신 예제 함수 */
async function sendPost(targetUrl, requestData) {
    try {
        let responseData = await axios ({
            method : 'post',
            url : targetUrl,
            data : requestData
        });

        return responseData.data;
    } catch (AxiosError) {
        console.log('본인확인 서버 통신URL이 잘 못 되었습니다.');
    }
}

app.listen(port, () => {
    console.log(`App listening at Port : ${port}`)
})
    views/mok_api_gettoken.ejs
     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
    <%#  // mok_api_server(mok_api_gettoken) 처리 기능 참조 %>
<% if (resultCode != 2000 || resultCode == 'undefined' || resultCode == '') { %>
<script>
    alert('<%- resultCode %>, <%- resultMsg %>');
</script>

    <% } else { %>
<script>
    document.addEventListener("DOMContentLoaded", function () {
        /* 정상작동시 */
        document.getElementById("MOKAuthRequestData").value = '<%- MOKAuthRequestData %>';
    });
</script>
    <% } %>
<html>
<head>
<meta charset="utf-8"/>
    <title>mok_api_gettoken</title>
</head>
<body>
    <form action='<%- requestUri %>' method="post">
        <p>서비스별 인증요청 정보(MOKAuthInfo)를  참고하여 작성</p>
        (공통 필수) <input type="text" required id="serviceType" name="serviceType"  value="" placeholder="telcoAuth" /> 이용상품 코드 (serviceType => "telcoAuth":휴대폰본인확인, telcoAuth-LMS : "휴대폰본인확인 LMS") <br>
        (공통 필수) <input type="text" required id="providerid" name="providerid" value="" placeholder="SKT" style="left-padding:10px" /> 인증 사업자 구분코드 (providerId => "SKT","KT","LGU","SKTMVNO","KTMVNO","LGUMVNO") <br>
        (공통 필수) <input type="text" required id="reqAuthType" name="reqAuthType" value="" placeholder="PASS" /> 본인확인 인증 처리 Type 코드 (reqAuthType => "SMS" : SMS인증, "PASS" : PASS앱 인증) <br>
        (공통 선택) <input type="text" id="usageCode" name="usageCode" value="" placeholder="01001" /> 서비스 이용 코드 (usageCode) <br>
        (공통 필수) <input type="text" id="retTransferType" name="retTransferType" value="MOKResult" /> 요청 대상의 결과 전송 타입 (retTransferType) <br>
        (공통 필수) <input type="text" required id="userName" name="userName" placeholder="홍길동" value="" /> 이름 (userName) <br>
        (공통 필수) <input type="tel" required id="userPhoneNum" name="userPhoneNum" value="" placeholder="숫자만 (-제외)" /> 핸드폰 번호 (userPhone) <br>
        <input type="tel" id="userBirthday" name="userBirthday" value="" placeholder="20000101" style="width:250px"/> 생년월일(8자리) (userBirthday) <br>
        <input type="text" id="userGender" name="userGender" value="" placeholder="남자 : 1, 여자 : 2" style="width:250px"/> 성별 (userGender => "1" : 남자, "2" : 여자) <br>
        <input type="text" id="userNation" name="userNation" value="" placeholder="내국인 : 0, 외국인 : 1" style="width:250px"/> 내외국인 정보 (userNation => "0" : 내국인, "1" : 외국인) <br>
        <textarea id="sendMsg" name="sendMsg" placeholder="본인확인 인증번호[000000]를 화면에 입력해주세요." style="width:250px"></textarea> SMS 전송 시 사용할 메시지로 사용할 값 (sendMsg)<br>
        <input type="text" id="replyNumber" name="replyNumber" value="" placeholder="15880000" style="width:250px"/> SMS 또는 ARS 전송 시 사용할 송신번호 (replyNumber) <br>
        <input type="text" id="arsCode" name="arsCode" placeholder="ARS-TEST-NVR-11" style="width:250px" /> 운영자와 협의 된 ARS 코드 (arsCode) <br>
        <input type="text" id="arsRequestMsg" name="arsRequestMsg" placeholder='{"companyName":"이용기관명"}' style="width:350px"/> ARS 점유인증 요청시 추가정보 입력 extension/arsRequestMsg <br>
        <input type="submit" style="width:400px; height:30px; margin-top:10px; margin-bottom:10px" value="요청하기"/><br>
        <input type="hidden" id="MOKAuthRequestData" name="MOKAuthRequestData" value=''/>
        <input type="hidden" id="normalFlag" name="normalFlag" value='Y'/>
    </form>

</body>
</html>
    mok_api_gettoken.aspx
     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
    <%@ Page Language="C#" Async="true" AutoEventWireup="true" CodeBehind="mok_api_gettoken.aspx.cs" Inherits="mok_api_gettoken"%>
<%@ Import Namespace="System" %>

<html>
<head runat="server">
    <meta charset="utf-8"/>
    <title>mok_api_gettoken</title>
</head>
<body>

<form action= <%= MOK_REQUEST_ASPX %> method="post">
    <p>서비스별 인증요청 정보(MOKAuthInfo)를  참고하여 작성</p>
    (공통 필수) <input type="text" required id="serviceType" name="serviceType"  value="" placeholder="telcoAuth" /> 이용상품 코드 (serviceType => "telcoAuth":휴대폰본인확인, telcoAuth-LMS : "휴대폰본인확인 LMS", telcoAuth-ARSAuth : "ARS") <br>
    (공통 필수) <input type="text" required id="providerid" name="providerid" value="" placeholder="SKT" /> 인증 사업자 구분코드 (providerId => "SKT","KT","LGU","SKTMVNO","KTMVNO","LGUMVNO") <br>
    (공통 필수) <input type="text" required id="reqAuthType" name="reqAuthType" value="" placeholder="PASS" /> 본인확인 인증 처리 Type 코드 (reqAuthType => "SMS" : SMS인증, "PASS" : PASS앱 인증) <br>
    (공통 선택) <input type="text" id="usageCode" name="usageCode" value="" placeholder="01001" /> 서비스 이용 코드 (usageCode) <br>
    (공통 필수) <input type="text" id="retTransferType" name="retTransferType" value="" /> 요청 대상의 결과 전송 타입 (retTransferType) <br>
    (공통 필수) <input type="text" required id="userName" name="userName" placeholder="홍길동" value="" /> 이름 (userName) <br> 
    (공통 필수) <input type="tel" required id="userPhoneNum" name="userPhoneNum" value="" placeholder="숫자만 (-제외)" /> 핸드폰 번호 (userPhone) <br>
    <input type="text" id="arsCode" name="arsCode" placeholder="ARS-TEST-NVR-11" style="width:250px" /> 운영자와 협의 된 ARS 코드 (arsCode) <br>
    <input type="tel" id="userBirthday" name="userBirthday" value="" placeholder="20000101" style="width:250px"/> 생년월일(8자리) (userBirthday) <br>
    <input type="text" id="userGender" name="userGender" value="" placeholder="남자 : 1, 여자 : 2" style="width:250px"/> 성별 (userGender => "1" : 남자, "2" : 여자) <br>
    <input type="text" id="userNation" name="userNation" value="" placeholder="내국인 : 0, 외국인 : 1" style="width:250px"/> 내외국인 정보 (userNation => "0" : 내국인, "1" : 외국인) <br>
    <textarea id="sendMsg" name="sendMsg" placeholder="[드림시큐리티] 인증번호 [000000]" style="width:250px"></textarea> SMS 전송 시 사용할 메시지로 사용할 값 (sendMsg)<br>
    <input type="text" id="replyNumber" name="replyNumber" value="" placeholder="15880000" style="width:250px"/> SMS 또는 ARS 전송 시 사용할 송신번호 (replyNumber) <br>
    <input type="text" id="arsRequestMsg" name="arsRequestMsg" placeholder='{"companyName":"이용기관명"}' style="width:350px"/> ARS 점유인증 요청시 추가정보 입력 extension/arsRequestMsg <br>
    <input type="submit" style="width:400px; height:30px; margin-top:10px; margin-bottom:10px" value="요청하기"/><br>

    <input type="hidden" id="MOKAuthRequestData" name="MOKAuthRequestData" value=''/>
    <input type="hidden" id="normalFlag" name="normalFlag" value='Y'/>
</form>
<form id="form1" runat="server">
<asp:HiddenField ID="MOKAuthRequestData" runat="server" />
    <script>
        function safeParseJSON(data) {
            try {
                return JSON.parse(data);
            } catch (error) {
                console.error('Error parsing JSON:', error);
                return null;
            }
        }

        function fetchMOKAuthRequestData() {
            fetch('mok_api_gettoken.aspx/GetMOKAuthRequestData', {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/json',
                },
                body: JSON.stringify({}),
            })
                .then(response => response.json())
                .then(data => {
                    const MOKAuthRequestData = safeParseJSON(data.d);

                    if (MOKAuthRequestData !== null) {
                        if (MOKAuthRequestData.resultCode !== '2000') {
                            /* 오류발생시 */
                            window.alert(MOKAuthRequestData.resultCode + ', ' + MOKAuthRequestData.resultMsg);
                        } else {
                            document.getElementById("MOKAuthRequestData").value = JSON.stringify(MOKAuthRequestData);
                        }
                    } else {
                        window.alert('Invalid JSON data:', data.d);
                    }
                })
                .catch(error => {
                    window.alert('Error fetching data:', error);
                });
        }

        document.addEventListener("DOMContentLoaded", function () {
            fetchMOKAuthRequestData();
        });
    </script>
</form>
</body>
</html>
    mok_api_gettoken.aspx.cs
      1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
    using System;
using System.Collections.Generic;
using System.Web;
using System.Web.Services;
using System.Web.UI;
using System.Web.UI.WebControls;

using System.Text;
using System.Web.UI.HtmlControls;
using System.Security.Authentication;

using System.Net;
using System.IO;

using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using System.Web.Services.Description;
using System.Security.Cryptography.X509Certificates;
using mokcrypto;

public partial class mok_api_gettoken : Page
{
private static string SessionClientTxId;


    /* 1. 본인확인 인증결과 MOKGetToken API 요청 URL */
    //protected static string MOK_GET_TOKEN_URL = "https://cert-dir.mobile-ok.com/agent/v1/token/get";  // 운영
    protected static string MOK_GET_TOKEN_URL = "https://scert-dir.mobile-ok.com/agent/v1/token/get";  // 개발
    /* 요청하기 버튼 클릭시 이동 aspx (mobileOK-Request aspx) */
    protected static string MOK_REQUEST_ASPX = "./mok_api_request.aspx";

    // 이용기관 거래ID생성시 이용기관별 유일성 보장을 위해 설정, 이용기관식별자는 이용기관코드 영문자로 반드시 수정
    protected static string PREFIX_ID = "본인확인 이용기관식별자 PREFIX";  // 8자이내 영대소문자,숫자 (예) MOK, TESTCOKR  

    protected void Page_Load(object sender, EventArgs e)
    {
        string randomClientId = PREFIX_ID + Guid.NewGuid().ToString("N");
        string clientTxId = randomClientId;
        DateTime dow = DateTime.Now;
        string formattedDate = dow.ToString("yyyyMMddHHmmss");
        string reqClientInfo = clientTxId + "|" + formattedDate;

        /* 2. 본인확인 서비스 함수 초기화 설정 */
        MobileOkKeyManager mobileOK = new MobileOkKeyManager();
        try
        {
            /* 키파일은 반드시 서버의 안전한 로컬경로에 별도 저장. 웹URL 경로에 파일이 있을경우 키파일이 외부에 노출될 수 있음 주의 */
            mobileOK.keyInit("/본인확인-API 키정보파일 Path/mok_keyInfo.dat", "키파일 패스워드");
            mobileOK.SetSiteUrl("본인확인-API 등록 사이트 URL");
        }
        catch (MobileOKException ex)
        {
            alertASPX(ex.Message);
        }
    }

    /* 본인확인-API 토큰요청 입력데이터 설정 예제 함수 */
    public string MOKGetTokenRequestToJsonString(
        MobileOkKeyManager mobileOK,
        string ServiceId,
        string sampleClientTxId,
        string siteUrl)
    {
        DateTime dow = DateTime.Now;
        string formattedDate = dow.ToString("yyyyMMddHHmmss");
        string reqClientInfo = sampleClientTxId + "|" + formattedDate;
        string encryptReqClientInfo = mobileOK.RSAEncrypt(reqClientInfo);
        //aaa = encryptReqClientInfo;

        Dictionary<string, object> MOKGettokenRequestJson = new Dictionary<string, object>();
        MOKGettokenRequestJson["serviceId"] = ServiceId;
        MOKGettokenRequestJson["encryptReqClientInfo"] = encryptReqClientInfo;
        MOKGettokenRequestJson["siteUrl"] = siteUrl;

        return JsonConvert.SerializeObject(MOKGettokenRequestJson);
    }

    [WebMethod]
    public string mobileOK_api_gettoken(MobileOkKeyManager mobileOK, HttpWebRequest request)
    {
        /* 3. 본인확인-API 거래ID 생성  */

        /* 3.1 이용기관 거래ID 생성, 20자 이상 40자 이내 이용기관 고유 트랜잭션ID (예시) 이용기관식별자+UUID, ...  */
        // - 본인확인-API 거래ID 는 유일한 값이어야 하며 기 사용한 거래ID가 있는 경우 오류 발생 
        // - 이용기관이 고유식별 ID로 유일성을 보장할 경우 고객이 이용하는 ID사용 가능 
        string sampleClientTxId = PREFIX_ID + Guid.NewGuid().ToString("N");


        /* 3.2 인증 결과 검증을 위한 거래 ID 세션 저장 */
        // 동일한 세션내 요청과 결과가 동일한지 확인 및 인증결과 재사용 방지처리, 응답결과 처리 시 필수 구현
        // 세션 내 거래ID를 저장하여 검증하는 방법은 권고 사항이며, 이용기관 저장매체(DB 등)에 저장하여 검증 가능
        HttpContext.Current.Session["sessionClientTxId"] = sampleClientTxId;


        // 4. 본인확인 토큰요청 데이터 설정 (아래 MOKGetTokenRequestToJsonString() 참조)
        string MOKGetTokenRequestJsonString = MOKGetTokenRequestToJsonString(mobileOK, mobileOK.ServiceId, sampleClientTxId, mobileOK.GetSiteUrl()); ;

        // 5. 본인확인 토큰요청
        string MOKGetTokenResponseJsonString = SendPost(MOK_GET_TOKEN_URL, MOKGetTokenRequestJsonString);

        // 6. 본인확인 토큰요청 후 응답 데이터 설정
        dynamic MOKGetTokenResponseJson = JObject.Parse(MOKGetTokenResponseJsonString);
        if ((int)MOKGetTokenResponseJson["resultCode"] == 2000)
        {
            return JsonConvert.SerializeObject(MOKGetTokenResponseJson);
        }

        // 6-1. 본인확인 인증요청 API에서 이용할 데이터 설정
        Dictionary<string, object> MOKAuthRequestData = new Dictionary<string, object>();
        MOKAuthRequestData["encryptMOKToken"] = MOKGetTokenResponseJson["encryptMOKToken"];
        MOKAuthRequestData["publicKey"] = MOKGetTokenResponseJson["publicKey"];
        MOKAuthRequestData["resultCode"] = MOKGetTokenResponseJson["resultCode"];
        MOKAuthRequestData["resultMsg"] = MOKGetTokenResponseJson["resultMsg"];

        string MOKAuthRequestDataString = JsonConvert.SerializeObject(MOKAuthRequestData);

        return MOKAuthRequestDataString;
    }

    /* 본인확인 서버 통신 예제 함수 */
    private string SendPost(string url, string json)
    {
        ServicePointManager.SecurityProtocol = (SecurityProtocolType)768 | (SecurityProtocolType)3072;
        HttpWebRequest request = (HttpWebRequest)WebRequest.Create(url);
        request.Method = "POST";
        request.ContentType = "application/json";

        byte[] data = Encoding.UTF8.GetBytes(json);
        request.ContentLength = data.Length;

        using (Stream stream = request.GetRequestStream())
        {
            stream.Write(data, 0, data.Length);
        }

        using (HttpWebResponse response = (HttpWebResponse)request.GetResponse())
        {
            if (response.StatusCode == HttpStatusCode.OK)
            {
                using (StreamReader reader = new StreamReader(response.GetResponseStream(), Encoding.UTF8))
                {
                    return reader.ReadToEnd();
                }
            }
            else
            {
                return null;
            }
        }
    }

    [WebMethod]
    public static string GetMOKAuthRequestData()
    {
        //api_get_gettoken.aspx에서 값 호출
        mok_api_gettoken moktok = new mok_api_gettoken();
        MobileOkKeyManager mobileOK = new MobileOkKeyManager();

        HttpWebRequest request = (HttpWebRequest)WebRequest.Create(MOK_GET_TOKEN_URL);
        request.Method = "POST";
        request.ContentType = "application/json";

        string jsonData = moktok.mobileOK_api_gettoken(mobileOK, request);

        return jsonData;
    }

    //aspx 페이지 오류알람 출력
    private void alertASPX(string errorMsg)
    {
        string script = "window.onload = function() { alert('" + errorMsg + "'); };";
        Page.ClientScript.RegisterStartupScript(this.GetType(), "alert", script, true);
    }
}
    GetTokenController.cs
      1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
    using Microsoft.AspNetCore.Mvc;
using Newtonsoft.Json.Linq;
using Newtonsoft.Json;
using mokcrypto;
using System.Threading.Tasks;
using System;
using System.Collections.Generic;
using Microsoft.AspNetCore.Http;
using System.Net.Http;
using System.IO;

namespace AspNetCoreAllInOne.Controllers
{
    public class GetTokenController : Controller
    {
        /*1. 본인확인 인증결과 MOKGetToken API 요청 URL*/
        //private string MOK_GET_TOKEN_URL = "https://cert-dir.mobile-ok.com/agent/v1/token/get";  // 운영
        private static string MOK_GET_TOKEN_URL = "https://scert-dir.mobile-ok.com/agent/v1/token/get";  // 개발

        // 이용기관 거래ID생성시 이용기관별 유일성 보장을 위해 설정, 이용기관식별자는 이용기관코드 영문자로 반드시 수정
        private static string PREFIX_ID = "본인확인 이용기관식별자 PREFIX";  // 8자이내 영대소문자,숫자 (예) MOK, TESTCOKR

        [HttpGet]
        public async Task<IActionResult> mok_api_gettoken()
        {
            /* 2. 본인확인 서비스 함수  설정 */
            MobileOkKeyManager mobileOK = new MobileOkKeyManager();
            try
            {
                /* 키파일은 반드시 서버의 안전한 로컬경로에 별도 저장. 웹URL 경로에 파일이 있을경우 키파일이 외부에 노출될 수 있음 주의 */
                mobileOK.keyInit("/본인확인-API 키정보파일 Path/mok_keyInfo.dat", "키파일 패스워드");
                mobileOK.SetSiteUrl("본인확인-API 등록 사이트 URL");

                ViewData["message"] = await mobileOK_api_gettoken(mobileOK);
                ViewData["isError"] = false;
            }
            catch (MobileOKException ex)
            {
                ViewData["message"] = ex.Message;
                ViewData["isError"] = true;
            }

            return View();
        }

        /* 본인확인-API 토큰요청 입력데이터 설정 예제 함수 */
        public string MOKGetTokenRequestToJsonString(
        MobileOkKeyManager mobileOK,
        string ServiceId,
        string sampleClientTxId,
        string siteUrl)
        {
            DateTime dow = DateTime.Now;
            string formattedDate = dow.ToString("yyyyMMddHHmmss");
            string reqClientInfo = sampleClientTxId + "|" + formattedDate;
            string encryptReqClientInfo = mobileOK.RSAEncrypt(reqClientInfo);

            Dictionary<string, object> MOKGettokenRequestJson = new Dictionary<string, object>();
            MOKGettokenRequestJson["serviceId"] = ServiceId;
            MOKGettokenRequestJson["encryptReqClientInfo"] = encryptReqClientInfo;
            MOKGettokenRequestJson["siteUrl"] = siteUrl;


            return JsonConvert.SerializeObject(MOKGettokenRequestJson);
        }

        /* 본인확인-API 토큰요청 예제 함수 */
        public async Task<string> mobileOK_api_gettoken(MobileOkKeyManager mobileOK)
        {
            /* 3. 본인확인-API 거래요청정보 생성  */

            /* 3.1 이용기관 거래ID 생성, 20자 이상 40자 이내 이용기관 고유 트랜잭션ID (예시) 이용기관식별자+UUID, ...  */
            // - 본인확인-API 거래ID 는 유일한 값이어야 하며 기 사용한 거래ID가 있는 경우 오류 발생 
            // - 이용기관이 고유식별 ID로 유일성을 보장할 경우 고객이 이용하는 ID사용 가능 
            string sampleClientTxId = PREFIX_ID + Guid.NewGuid().ToString("N");

            /* 3.2 인증 결과 검증을 위한 거래 ID 세션 저장 */
            // 동일한 세션내 요청과 결과가 동일한지 확인 및 인증결과 재사용 방지처리, 응답결과 처리 시 필수 구현
            // 세션 내 거래ID를 저장하여 검증하는 방법은 권고 사항이며, 이용기관 저장매체(DB 등)에 저장하여 검증 가능
            HttpContext.Session.SetString("sessionClientTxId", sampleClientTxId);

            // 4. 본인확인 토큰요청 데이터 설정 (아래 MOKGetTokenRequestToJsonString() 참조)
            string MOKGetTokenRequestJsonString = MOKGetTokenRequestToJsonString(mobileOK
                , mobileOK.ServiceId    /* 본인확인 서비스 ID */
                , sampleClientTxId      /* 암호화된 이용기관 식별 ID */
                , mobileOK.GetSiteUrl() /* 본인확인-API 등록 사이트 URL */
                );

            // 5. 본인확인 토큰요청
            string MOKGetTokenResponseJsonString = await SendPost(MOK_GET_TOKEN_URL, MOKGetTokenRequestJsonString);

            // 6. 본인확인 토큰요청 후 응답 데이터 설정
            dynamic MOKGetTokenResponseJson = JObject.Parse(MOKGetTokenResponseJsonString);
            if ((int)MOKGetTokenResponseJson["resultCode"] == 2000)
            {
                return JsonConvert.SerializeObject(MOKGetTokenResponseJson);
            }

            // 6-1. 본인확인 인증요청 API에서 이용할 데이터 설정
            Dictionary<string, object> MOKAuthRequestData = new Dictionary<string, object>();
            MOKAuthRequestData["encryptMOKToken"] = MOKGetTokenResponseJson["encryptMOKToken"];
            MOKAuthRequestData["publicKey"] = MOKGetTokenResponseJson["publicKey"];
            MOKAuthRequestData["resultCode"] = MOKGetTokenResponseJson["resultCode"];
            MOKAuthRequestData["resultMsg"] = MOKGetTokenResponseJson["resultMsg"];

            string MOKAuthRequestDataString = JsonConvert.SerializeObject(MOKAuthRequestData);

            return MOKAuthRequestDataString;
        }

        /* 본인확인 서버 통신 예제 함수 */
        private async Task<string> SendPost(string url, string json)
        {
            try
            {
                HttpClient client = new HttpClient();

                var content = new StringContent(json, System.Text.Encoding.UTF8, "application/json");

                var response = await client.PostAsync(url, content);

                if (response.IsSuccessStatusCode)
                {
                    string responseString = await response.Content.ReadAsStringAsync();
                    return responseString;
                }
                else
                {
                    return null;
                }
            }
            catch (HttpRequestException ex)
            {
                Console.WriteLine("HttpRequestException: " + ex.Message);
                return null;
            }
            catch (TaskCanceledException ex)
            {
                Console.WriteLine("TaskCanceledException: " + ex.Message);
                return null;
            }
            catch (IOException ex)
            {
                Console.WriteLine("IOException: " + ex.Message);
                return null;
            }
        }
    }
}
    mok_api_gettoken.cshtml
     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
    @{
/* 요청하기 버튼 클릭시 이동 (mok_api_request) */
bool IsError = (bool)ViewData["IsError"];
string MOK_REQUEST_CSHTML = "./mok_api_request";
}

<html>
<head>
    <meta charset="utf-8" />
    <title>mok_api_gettoken</title>

    @if (@IsError)
    {
        <script>
            window.onload = function () { alert('@Html.Raw(@ViewData["message"])'); };
        </script>
    }
    else
    {
        <script>
            const MOKAuthRequestData = @Html.Raw(ViewData["message"])
                            if (MOKAuthRequestData.resultCode != '2000') {
                /* 오류발생시 */
                window.alert(MOKAuthRequestData.resultCode + ', ' + MOKAuthRequestData.resultMsg);
            }
            else {
                document.addEventListener("DOMContentLoaded", function () {
                    /* 정상작동시 */
                    document.getElementById("MOKAuthRequestData").value = JSON.stringify(MOKAuthRequestData);
                });
            }
        </script>
    }

</head>
<body>
    <form action=@MOK_REQUEST_CSHTML method="post">
        (공통 필수) <input type="text" required id="serviceType" name="serviceType" value="" placeholder="telcoAuth" /> 이용상품 코드 (serviceType => "telcoAuth":휴대폰본인확인, telcoAuth-LMS : "휴대폰본인확인 LMS", telcoAuth-ARSAuth : "ARS") <br>
        (공통 필수) <input type="text" required id="providerid" name="providerid" value="" placeholder="SKT" style="left-padding:10px" /> 인증 사업자 구분코드 (providerId => "SKT","KT","LGU","SKTMVNO","KTMVNO","LGUMVNO") <br>
        (공통 필수) <input type="text" required id="reqAuthType" name="reqAuthType" value="" placeholder="PASS" /> 본인확인 인증 처리 Type 코드 (reqAuthType => "SMS" : SMS인증, "PASS" : PASS앱 인증, "ARS" : "ARS") <br>
        (공통 선택) <input type="text" id="usageCode" name="usageCode" value="" placeholder="01001" /> 서비스 이용 코드 (usageCode) <br>
        (공통 필수) <input type="text" id="retTransferType" name="retTransferType" value="MOKResult" /> 요청 대상의 결과 전송 타입 (retTransferType) <br>
        (공통 필수) <input type="text" required id="userName" name="userName" placeholder="홍길동" value="" /> 이름 (userName) <br>
        (공통 필수) <input type="tel" required id="userPhoneNum" name="userPhoneNum" value="" placeholder="숫자만 (-제외)" /> 핸드폰 번호 (userPhone) <br>
        <input type="tel" id="userBirthday" name="userBirthday" value="" placeholder="20000101" style="width:250px" /> 생년월일(8자리) (userBirthday) <br>
        <input type="text" id="userGender" name="userGender" value="" placeholder="남자 : 1, 여자 : 2" style="width:250px" /> 성별 (userGender => "1" : 남자, "2" : 여자) <br>
        <input type="text" id="userNation" name="userNation" value="" placeholder="내국인 : 0, 외국인 : 1" style="width:250px" /> 내외국인 정보 (userNation => "0" : 내국인, "1" : 외국인) <br>
        <textarea id="sendMsg" name="sendMsg" placeholder="본인확인 인증번호[000000]를 화면에 입력해주세요." style="width:250px"></textarea> SMS 전송 시 사용할 메시지로 사용할 값 (sendMsg)<br>
        <input type="text" id="replyNumber" name="replyNumber" value="" placeholder="15880000" style="width:250px" /> SMS 또는 ARS 전송 시 사용할 송신번호 (replyNumber) <br>
        <input type="text" id="arsCode" name="arsCode" placeholder="ARS-TEST-NVR-11" style="width:250px" /> 운영자와 협의 된 ARS 코드 (arsCode) <br>
        <input type="text" id="arsRequestMsg" name="arsRequestMsg" placeholder='{"companyName":"이용기관명"}' style="width:350px" /> ARS 점유인증 요청시 추가정보 입력 extension/arsRequestMsg <br>
        <input type="submit" style="width:400px; height:30px; margin-top:10px; margin-bottom:10px" value="요청하기" /><br>

        <input type="hidden" id="MOKAuthRequestData" name="MOKAuthRequestData" value='' />
        <input type="hidden" id="normalFlag" name="normalFlag" value='Y' />
    </form>

</body>
</html>

5. 본인확인-API 인증요청

본인확인을 위한 사용자 개인정보 및 관련정보를 본인확인-API 인증요청 인터페이스에 요청 및 응답을 수신합니다.

  • 본인확인-API 인증요청/재요청 연동 URL 및 인증요청 정보

    • URL

      • 본인확인-API 인증요청

        • 운영 : https://cert-dir.mobile-ok.com/agent/v1/auth/request

        • 개발 : https://scert-dir.mobile-ok.com/agent/v1/auth/request

      • 본인확인-API 인증 재요청

        • 운영 : https://cert-dir.mobile-ok.com/agent/v1/auth/resend

        • 개발 : https://scert-dir.mobile-ok.com/agent/v1/auth/resend

    • HTTPS 암호화 통신 : TLS 1.2 이상

    • HTTP 메소드 : POST

    • Charset : utf-8

5.1 서비스별 인증요청 정보 생성

5.1.1 휴대폰본인확인

  • 휴대폰본인확인 요청 원문 MOKAuthInfo 생성

    속성 값 필수여부
    serviceType 이용상품 코드
    - “telcoAuth” : 휴대폰본인확인 SMS/PASS 인증 서비스    		 ●
    providerId 서비스 제공 이동통신사 및 서비스
    - “SKT”
    - “KT”
    - “LGU”
    - “SKTMVNO”
    - “KTMVNO”
    - “LGUMVNO”    		 ●
    reqAuthType 본인확인 인증 Type 코드, 인증번호 전송 타입 또는 인증방법
    -“PASS”    		 ●
    usageCode 서비스 이용 코드
    - “01001” : 회원가입
    - “01002” : 정보변경
    - “01003” : ID찾기
    - “01004” : 비밀번호찾기
    - “01005” : 본인확인용
    - “01007” : 상품구매/결제
    - “01999” : 기타    		 ●
    userName 사용자명 ●
    userPhone 사용자 핸드폰 번호 ●
    userBirthday 사용자 생년월일 (8자리)
    retTransferType 요청 대상의 결과 전송 타입
    - 개인정보 서버 수신 모드 : MOKResult    		 ●
    속성 값 필수여부
    serviceType 이용상품 코드
    - “telcoAuth” : 휴대폰본인확인 SMS/PASS 인증 서비스    		 ●
    providerId 서비스 제공 이동통신사 및 서비스
    - “SKT”
    - “KT”
    - “LGU”
    - “SKTMVNO”
    - “KTMVNO”
    - “LGUMVNO”    		 ●
    reqAuthType 본인확인 인증 Type 코드, 인증번호 전송 타입 또는 인증방법
    -“SMS”    		 ●
    usageCode 서비스 이용 코드
    - “01001” : 회원가입
    - “01002” : 정보변경
    - “01003” : ID찾기
    - “01004” : 비밀번호찾기
    - “01005” : 본인확인용
    - “01007” : 상품구매/결제
    - “01999” : 기타    		 ●
    userName 사용자명 ●
    userPhone 사용자 핸드폰 번호 ●
    userBirthday 사용자 생년월일 (8자리) ●
    userRegistSingleNumber 사용자 주민번호 뒤 자리 첫번째 숫자이며, 해당 파라미터가 사용되는 경우
    userGender와 userNation값은 무시됩니다.
    userGender 사용자 성별
    - “1” : 남자
    - “2”: 여자    		 ●
    userNation 사용자 내외국인 정보
    - “0” : 내국인
    - “1”: 외국인    		 ●
    sendMsg SMS 전송 시 사용할 80Byte 이내 메시지. NULL 또는 속성이 없을경우 가입시 등록한 이용기관 기본메시지 전송.
    (예) ㅇㅇㅇㅇ 인증번호 [000000] 입니다.
    replyNumber SMS 전송 시 사용할 송신번호 입력, NULL 또는 속성이 없을경우 서비스에
    등록된 이용기관 전화번호 또는 휴대폰본인확인 콜센터 번호 입력
    retTransferType 요청 대상의 결과 전송 타입
    - 개인정보 서버 수신 모드 : MOKResult    		 ●
    extension 이용기관별 추가정보 전달처리시 이용 데이터 JSON Object
    • 이용기관은 본인확인 서비스 가입시 이용기관용 SMS전송 기본 메시지를 본인확인 담당자에게 등록할 수 있습니다.
    • sendMsg 정보에 내용이 없을경우 기본메시지가 사용자에게 전송됩니다.
    • (예) 본인확인 인증번호[000000]를 화면에 입력해주세요
    속성 값 필수여부
    serviceType 이용상품 코드
    - “telcoAuth” : 휴대폰본인확인 SMS/PASS 인증 서비스    		 ●
    providerId 서비스 제공 이동통신사 및 서비스
    - “SKT”
    - “KT”
    - “LGU”
    - “SKTMVNO”
    - “KTMVNO”
    - “LGUMVNO”    		 ●
    reqAuthType 본인확인 인증 Type 코드, 인증번호 전송 타입 또는 인증방법
    -“SMS”    		 ●
    usageCode 서비스 이용 코드
    - “01016” : 성인인증 (민법)
    - “01026” : 성인인증 (청소년보호법)    		 ●
    userName 사용자명 ●
    userPhone 사용자 핸드폰 번호 ●
    userBirthday 사용자 생년월일 (8자리) ●
    userRegistSingleNumber 사용자 주민번호 뒤 자리 첫번째 숫자이며, 해당 파라미터가 사용되는 경우
    userGender와 userNation값은 무시됩니다.
    userGender 사용자 성별
    - “1” : 남자
    - “2”: 여자    		 ●
    userNation 사용자 내외국인 정보
    - “0” : 내국인
    - “1”: 외국인    		 ●
    sendMsg SMS 전송 시 사용할 80Byte 이내 메시지. NULL 또는 속성이 없을경우 가입시 등록한 이용기관 기본메시지 전송.
    (예) ㅇㅇㅇㅇ 인증번호 [000000] 입니다.
    replyNumber SMS 전송 시 사용할 송신번호 입력, NULL 또는 속성이 없을경우 서비스에 등록된 이용기관 전화번호 또는 휴대폰본인확인 콜센터 번호 입력
    retTransferType 요청 대상의 결과 전송 타입
    - 개인정보 서버 수신 모드 : MOKResult    		 ●
    extension 이용기관별 추가정보 전달처리시 이용 데이터 JSON Object
    • 이용기관은 본인확인 서비스 가입시 이용기관용 SMS전송 기본 메시지를 본인확인 담당자에게 등록할 수 있습니다.
    • sendMsg 정보에 내용이 없을경우 기본메시지가 사용자에게 전송됩니다.
    • (예) 본인확인 인증번호[000000]를 화면에 입력해주세요

  • 인증요청 정보 MOKAuthInfo JSON 예시

    {
    "serviceType": "telcoAuth",
    "providerId" : "LGU",
    "reqAuthType" : "PASS",
    "usageCode": "01001",
    "retTransferType" : "MOKResult",
    "userName" : "홍길동", 
    "userPhone" : "01012345678"
} 

    {
    "serviceType": "telcoAuth",
    "providerId" : "SKT",
    "reqAuthType" : "SMS",
    "usageCode": "01001",
    "userName" : "홍길동", 
    "userPhone" : "01012345678",
    "userBirthday" : "20000101", 
    "userGender" : "1", 
    "userNation" : "0",
    "sendMsg" : "본인확인 인증번호[000000]를 화면에 입력해주세요.",
    "replyNumber" : "0211112222",
    "retTransferType" : "MOKResult"
}

    {
    "serviceType": "telcoAuth",
    "providerId" : "SKT",
    "reqAuthType" : "SMS",
    "usageCode": "01016",
    "userName" : "홍길동", 
    "userPhone" : "01012345678",
    "userBirthday" : "20000101", 
    "userGender" : "1", 
    "userNation" : "0",
    "sendMsg" : "본인확인 인증번호[000000]를 화면에 입력해주세요.",
    "replyNumber" : "0211112222",
    "retTransferType" : "MOKResult"
}

5.1.2 휴대폰본인확인+LMS

휴대폰본인확인+LMS 서비스 이용시 본인확인 서비스 담당장에게 메시지 전송 기본메시지를 미리 등록 하여야 합니다. 또한, LMS 메시지를 매번 전송할 경우 통신용량이 커지므로 등록된 기본 메시지 사용을 권고합니다.

  • 휴대폰본인확인+LMS 요청 원문 MOKAuthInfo 생성

    속성 값 필수여부
    serviceType 이용상품 코드
    - “telcoAuth-LMS” : 휴대폰본인확인 LMS 문자 안내 전송 서비스    		 ●
    providerId 서비스 제공 이동통신사 및 서비스
    - “SKT”
    - “KT”
    - “LGU”
    - “SKTMVNO”
    - “KTMVNO”
    - “LGUMVNO”    		 ●
    reqAuthType 본인확인 인증 Type 코드, 인증번호 전송 타입 또는 인증방법
    -“LMS”    		 ●
    usageCode 서비스 이용 코드
    - “01001” : 회원가입
    - “01002” : 정보변경
    - “01003” : ID찾기
    - “01004” : 비밀번호찾기
    - “01005” : 본인확인용
    - “01007” : 상품구매/결제
    - “01999” : 기타    		 ●
    userName 사용자명 ●
    userPhone 사용자 핸드폰 번호 ●
    userBirthday 사용자 생년월일 ●
    userGender 사용자 성별
    - “1” : 남자
    - “2”: 여자    		 ●
    userNation 사용자 내외국인 정보
    - “0” : 내국인
    - “1”: 외국인    		 ●
    sendMsg LMS 전송 시 사용할 2000Byte 이내 메시지. 서비스 가입시 등록한 메시지 이용권고(속성값에 NULL 또는 속성 미 이용)
    (예)본인확인 인증번호[000000]를 화면에 입력해주세요
    replyNumber LMS 전송 시 사용할 송신번호 입력, NULL 또는 속성이 없을경우 서비스에 등록된 이용기관 전화번호 또는 휴대폰본인확인 콜센터 번호 입력
    retTransferType 요청 대상의 결과 전송 타입
    - 개인정보 서버 수신 모드 : MOKResult    		 ●
    extension 이용기관별 추가정보 전달처리시 이용 JSON Object

  • 인증요청 정보 MOKAuthInfo JSON 예시

    • LMS 요청의 경우 
      {
    "serviceType": "telcoAuth-LMS",
    "providerId" : "SKT",
    "reqAuthType" : "LMS",
    "usageCode": "01001",
    "userName" : "홍길동", 
    "userPhone" : "01012345678",
    "userBirthday" : "20001010", 
    "userGender" : "1", 
    "userNation" : "0",
    "sendMsg" : "본인확인 인증번호[000000]를 화면에 입력해주세요.",
    "replyNumber" : "0211112222",
    "retTransferType" : "MOKResult"
}

5.1.3 휴대폰본인확인+ARS

휴대폰본인확인+ARS 인증 서비스는 휴대폰본인확인 및 소유한 휴대폰으로 ARS 인증을 수행하여 본인확인을 수행하는 서비스입니다.

이 서비스를 이용하기 위해서는 본인확인담당자와 ARS 전용 통신사ID 생성 및 ARS-CODE 를 할당 받아야 합니다.

또한 이용기관은 표준 ARS 안내멘트가 아닌 별도 ARS 안내멘트 처리, 회사명등 추가 정보가 발생될 경우 본인확인 담당자와 관련 처리절차 진행후 서비스가 제공됩니다.

  • 휴대폰본인확인+ARS인증 요청 원문 MOKAuthInfo 생성

    속성 값 필수여부
    serviceType 이용상품 코드
    - “telcoAuth-ARSAuth” : 휴대폰본인확인+ARS 인증    		 ●
    providerId 서비스 제공 이동통신사 및 서비스
    - “SKT”
    - “KT”
    - “LGU”
    - “SKTMVNO”
    - “KTMVNO”
    - “LGUMVNO”    		 ●
    reqAuthType ARS 본인확인 인증 Type 코드
    - “ARS” : 인증번호 ARS 전송 타입    		 ●
    usageCode 서비스 이용 코드
    - “01001” : 회원가입
    - “01002” : 정보변경
    - “01003” : ID찾기
    - “01004” : 비밀번호찾기
    - “01005” : 본인확인용
    - “01007” : 상품구매/결제
    - “01999” : 기타    		 ●
    arsCode ARS인증을 사용하는 이용기관별로 등록된 ARS 코드 입력 ●
    userName 사용자명 ●
    userPhone 사용자 핸드폰 번호 ●
    userBirthday 사용자 생년월일 ●
    userGender 사용자 성별
    - “1” : 남자
    - “2”: 여자    		 ●
    userNation 사용자 내외국인 정보
    - “0” : 내국인
    - “1”: 외국인    		 ●
    replyNumber ARS 전송 시 사용할 송신번호 입력, NULL 또는 속성이 없을경우 서비스에 등록된 이용기관 전화번호 또는 휴대폰본인확인 콜센터 번호 입력
    retTransferType 요청 대상의 결과 전송 타입
    - 개인정보 서버 수신 모드 : MOKResult    		 ●
    extension 이용기관별 추가정보 전달처리시 이용 JSON Object
    - ARS 점유인증 추가정보 요청 필드 : “arsRequestMsg”

  • ARS 인증요청 정보 MOKAuthInfo JSON 예시

    {
    "serviceType": "telcoAuth-ARSAuth",
    "providerId" : "SKT",
    "reqAuthType" : "ARS",
    "usageCode": "01001",
    "arsCode" : "ARS-COM-XXXX", 
    "userName" : "홍길동", 
    "userPhone" : "01012345678",
    "userBirthday" : "20000101", 
    "userGender" : "1", 
    "userNation" : "0",
    "replyNumber" : "0211112222",
    "retTransferType" : "MOKResult"
}

    {
    "serviceType": "telcoAuth-ARSAuth",
    "providerId" : "KT",
    "reqAuthType" : "ARS",
    "usageCode": "01001",
    "arsCode" : "ARS-MOK-XXXX", 
    "userName" : "홍길동", 
    "userPhone" : "01012345678",
    "userBirthday" : "20000101", 
    "userGender" : "1", 
    "userNation" : "0",
    "replyNumber" : "0211112222",
    "retTransferType" : "MOKResult",
    "extension":{"arsRequestMsg":"{\"companyName\":\"이용기관명\"}"}
}

5.1.4 SMS 소유인증

SMS 소유인증 서비스는 휴대폰으로 인증번호(OTP)를 전달하여 확인하는 서비스 입니다.

  • SMS 소유인증 요청 원문 MOKAuthInfo 생성

    속성 값 필수여부
    serviceType 이용상품 코드
    - “SMSAuth” : 휴대폰 SMS 소유 인증    		 ●
    providerId 소유인증 서비스
    -“SMS”    		 ●
    reqAuthType SMS 소유인증 Type 코드
    - “SMS”    		 ●
    usageCode 서비스 이용 코드
    - “01001” : 회원가입
    - “01002” : 정보변경
    - “01003” : ID찾기
    - “01004” : 비밀번호찾기
    - “01005” : 본인확인용
    - “01007” : 상품구매/결제
    - “01999” : 기타    		 ●
    userName 사용자명 ●
    userPhone 사용자 핸드폰 번호 ●
    sendMsg SMS 전송 타입 사용시 사용할 80Byte 이내 메시지. NULL 또는 속성이 없을경우 가입시 등록한 이용기관 기본메시지 전송.
    (예) ㅇㅇㅇㅇ 인증번호 [000000] 입니다.
    replyNumber SMS 전송 시 사용할 송신번호 입력, NULL 또는 속성이 없을경우 서비스에 등록된 이용기관 전화번호 또는 휴대폰본인확인 콜센터 번호 입력
    retTransferType 요청 대상의 결과 전송 타입
    - 개인정보 서버 수신 모드 : MOKResult    		 ●
    extension 이용기관별 추가정보 전달처리시 이용 JSON Object

  • SMS 소유인증 인증요청 정보 MOKAuthInfo JSON 예시

    • SMSAuth 요청의 경우

      {
    "serviceType": "SMSAuth",
    "providerId" : "SMS",
    "reqAuthType" : "SMS",
    "userName" : "홍길동", 
    "userPhone" : "01012345678",
    "sendMsg" : "본인확인 인증번호[000000]를 화면에 입력해주세요.",
    "replyNumber" : "0211112222",
    "retTransferType" : "MOKResult"
}

5.2 본인확인 인증요청 생성

  • 본인확인-API 인증요청

    • 본인확인-API 인증요청 정보

      속성 값 필수여부
      siteUrl 본인확인-API 인증요청 이용기관 등록 도메인(예시, www.mobile-ok.com, TESTCOKR) ●
      encryptMOKToken 본인확인-API 거래토큰 요청 후 수신받은 암호화된 토큰 ●
      encryptMOKAuthInfo 암호화 된 사용자 정보 ● 
      {
    "siteUrl" : "www.mobile-ok.com",
    "encryptMOKToken" : "[kpGa50NSI7I6Ijezxm2DdePdKOx9SWMLDwheeOOKs...mAg4kfXc6nZgXxfnLnfAl+6rdPU32Lk13NQTXFwh/unIr+3PVFTEe8GBg==",
    "encryptMOKAuthInfo":"dQFxgLZ0r7eUFsQXy4x889sav/vnUC7tLL/Hz3K/HlmHHxaH6orDQs5TwA1/j8nmmnZhFXR19vUBgsUYkvjOt5L3E37f/tNYZjATxGbCPMLt4zAc/AtJjOcXO9BFqKF3KugDmDFp6TN5ct7QUoGQm4lLYavtdfH7s/J/ZWQaw97EGQzMuQjI++juy+JhgeKn13wcJOi00BMfXRSSNl7ZNnVmooYUCxag43bK1Xn0kdq9KcvqnF75R...DfmusSJvpXj+ghyvg="
}

    • 본인확인-API 인증 재요청(인증요청 오류 발생후 재요청시)

      • 본인확인-API 인증요청 정보

        속성 값 필수여부
        encryptMOKToken 암호화된 본인확인-API 거래 토큰 ● 
        {
    "encryptMOKToken" : "[kpGa50NSI7I6Ijezxm2DdePdKOx9SWMLDwheeOOKs...mAg4kfXc6nZgXxfnLnfAl+6rdPU32Lk13NQTXFwh/unIr+3PVFTEe8GBg=="
}

  • 본인확인-API 인증요청 응답 JSON

    • 본인확인-API 인증요청 응답 JSON 설명

      속성 값 필수여부
      resultCode 응답 결과 코드
      -2000일 경우 성공
      -2000이 아닐 경우 에러처리      		 ●
      resultMsg resultCode 가 2000이 아닐 경우 에러 메시지 ●
      otpCode 서비스제공자에게 받은 인증번호(OTP). SMS소유인증 등 인증번호 제공받는 이용기관만 사용
      arsOtpNumber ARS 점유인증 시 사용되는 인증번호. ARS 점유인증 서비스 제공받는 이용기관만 사용
      encryptMOKToken 암호화된 본인확인-API 거래 토큰 ●
      resendCount 인증요청 재 발송 가능횟수, 1번 잘못된 인증요청 시도 후 2(남은 재시도 횟수) 응답

    • 인증요청 응답 JSON 예시

      {
    "encryptMOKToken" : "[hzOoAv60ZlzuAf1km9o8i8wlJo8x2uvBwTlFNItwaCF0EKK2PvHqv+yivqUqvU1d/ShmMyW0vEKG8hw9TlubnN+Tkg...3I5VTJexA8nIsVPa8UCH1kmK8rQ0zX99YgHhzC7wCoGeOEcrENGYGYVUrV/wp2J8lg8KbfCUev/+bDhowIPsa",
    "resultCode" : "2000",
    "resultMsg" : "success"
}

      {
    "encryptMOKToken" : "[hzOoAv60ZlzuAf1km9o8i8wlJo8x2uvBwTlFNItwaCF0EKK2PvHqv+yivqUqvU1d/ShmMyW0vEKG8hw9TlubnN+Tkg...3I5VTJexA8nIsVPa8UCH1kmK8rQ0zX99YgHhzC7wCoGeOEcrENGYGYVUrV/wp2J8lg8KbfCUev/+bDhowIPsa",
    "resultCode" : "2000",
    "otpCode" : "123456",
    "resultMsg" : "success"
}

      {
    "encryptMOKToken" : "[hzOoAv60ZlzuAf1km9o8i8wlJo8x2uvBwTlFNItwaCF0EKK2PvHqv+yivqUqvU1d/ShmMyW0vEKG8hw9TlubnN+Tkg...3I5VTJexA8nIsVPa8UCH1kmK8rQ0zX99YgHhzC7wCoGeOEcrENGYGYVUrV/wp2J8lg8KbfCUev/+bDhowIPsa",
    "arsOtpNumber" : "123456", 
    "resultCode" : "2000",
    "resultMsg" : "success"
}

  • 본인확인-API 인증요청 요청 및 응답 처리 예제

    mok_api_request.jsp
      1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
    <%@page import="java.net.URLDecoder"%>
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<%@ page import="java.net.HttpURLConnection" %>
<%@ page import="java.net.URL" %>
<%@ page import="java.net.URLEncoder" %>
<%@ page import="java.util.UUID" %>
<%@ page import="java.io.*" %>
<%@ page import="java.io.IOException" %>
<%@ page import="com.dreamsecurity.json.JSONObject" %>
<%@ page import="com.dreamsecurity.json.JSONException" %>
<%@ page import="com.dreamsecurity.mobileOK.mobileOKKeyManager" %>
<%@ page import="com.dreamsecurity.mobileOK.MobileOKException" %>

<%!
    /*1. 본인확인 인증결과 MOKAuth API 또는 MOKResend API 요청 URL*/
    // private final String MOK_REQUEST_URL = "https://cert-dir.mobile-ok.com/agent/v1/auth/request";   // 운영
    private final String MOK_REQUEST_URL = "https://scert-dir.mobile-ok.com/agent/v1/auth/request";  // 개발
    // private final String MOK_RESEND_URL = "https://cert-dir.mobile-ok.com/agent/v1/auth/resend";        //운영
    private final String MOK_RESEND_URL = "https://scert-dir.mobile-ok.com/agent/v1/auth/resend";        // 개발

    /* 완료 버튼 클릭시 이동 JSP (mobileOK-Result JSP)*/
    private final String MOK_RESULT_JSP = "./mok_api_result.jsp";
    /* 취소 버튼 클릭시 이동 JSP (mobileOK-GetToken JSP)*/
    private final String MOK_GET_TOKEN_JSP = "./mok_api_gettoken.jsp";
    /* 재전송 버튼 클릭시 이동 JSP (mobileOK-GetToken JSP)*/
    private final String MOK_REQUEST_JSP = "./mok_api_request.jsp";
    /* 전화걸기 버튼 클릭시 이동 JSP (mobileOK-CALL JSP) => ARS일 경우*/
    private final String MOK_CALL_JSP = "./mok_ars_call.jsp";
%>

<%
    request.setCharacterEncoding("utf-8");
    /*2. 본인확인 서비스 API 초기화 */
    mobileOKKeyManager mobileOK = new mobileOKKeyManager();

    /* 키파일은 반드시 서버의 안전한 로컬경로에 별도 저장. 웹URL 경로에 파일이 있을경우 키파일이 외부에 노출될 수 있음 주의 */
    mobileOK.keyInit("/본인확인-API 키정보파일 Path/mok_keyInfo.dat", "키파일 패스워드");
    mobileOK.setSiteUrl("본인확인-API 등록 사이트 URL");

    // 재전송 여부 확인용
    String resendData = request.getParameter("MOKAuthResendData");
    // 정상요청 여부 확인용
    String normalFlag = request.getParameter("normalFlag");
    // 검증 재시도 여부 확인용
    String retryData = request.getParameter("MOKConfirmRetryData");

    /* 2-1. 현재 페이지의 요청 정보 (정상요청 / 재전송 요청 / 검증 재시도 / 비정상적인 요청)에 따른 실행 */
    String resultData = "";
    if ("Y".equals(normalFlag)) {
        System.out.println("정상요청 (Auth Request)");
        resultData = mobileOK_api_auth_request(mobileOK, request);
    } else if (!"".equals(resendData) && resendData != null) {
        System.out.println("재전송 요청 (resend)");
        try {
            resendData = URLDecoder.decode(resendData, "UTF-8");
        } catch(UnsupportedEncodingException e) {
            resultData = setErrorMsg("URLDecoding에 실패했습니다.");
        }
        resultData = mok_api_auth_resend(resendData);
    } else if (!"".equals(retryData) && retryData != null) {
        System.out.println("검증 재시도 (Confirm Retry)");
        try {
            retryData = URLDecoder.decode(retryData, "UTF-8");
        } catch(UnsupportedEncodingException e) {
            resultData = setErrorMsg("URLDecoding에 실패했습니다.");
        }

        JSONObject retryDataJson = new JSONObject(retryData);
        retryDataJson.put("resultCode", "2000");  // 검증 재시도 요청에 성공했을 경우

        try{
            resultData = URLEncoder.encode(retryDataJson.toString(), "UTF-8");
        } catch (UnsupportedEncodingException e) {
            setErrorMsg("URLEncoding에 실패했습니다.");
        }
    } else {
        resultData = setErrorMsg("올바르지 않는 인증 사업자 구분코드 또는 본인확인 인증 처리 Type 입니다.");
    }
%>

<%!
    /* 본인확인-API 인증요청 예제 함수 */
    public String mobileOK_api_auth_request(mobileOKKeyManager mobileOK, HttpServletRequest request) throws MobileOKException {
        String MOKAuthRequestData = request.getParameter("MOKAuthRequestData");
        JSONObject MOKAuthRequestJson = new JSONObject(MOKAuthRequestData);

        /* 3. 본인확인 인증요청 입력정보 설정 (아래 MOKAuthInfoToJson() 참조) */
        String MOKAuthRequestJsonString = "";
        if ("PASS".equals(request.getParameter("reqAuthType"))){
            MOKAuthRequestJsonString = MOKAuthRequestToJsonString(
                mobileOK
                , MOKAuthRequestJson.getString("publicKey")       /* MOK_API_Gettoken 응답으로 받은 publicKey */
                , MOKAuthRequestJson.getString("encryptMOKToken") /* MOK_API_Gettoken 응답으로 받은 encryptMOKToken */
                , mobileOK.getSiteUrl()                   /* 본인확인-API 등록 사이트 URL */
                , request.getParameter("providerid")      /* 인증 사업자 구분코드 */
                , request.getParameter("reqAuthType")     /* 본인확인 인증 처리 Type 코드 */
                , request.getParameter("usageCode")       /* 서비스 이용 코드 */
                , request.getParameter("serviceType")     /* 이용상품 코드 */
                , request.getParameter("userName")        /* 사용자 이름 */
                , request.getParameter("userPhoneNum")    /* 사용자 전화번호 */
                , request.getParameter("retTransferType") /* 요청 대상의 결과 전송 타입 */
                , ""                                      /* 운영자와 협의 된 ARS 코드 */
                , ""                                      /* 사용자 생년월일 */
                , ""                                      /* 사용자 성별 */
                , ""                                      /* 사용자 내외국인 정보 */
                , ""                                      /* SMS 발송내용 또는 LMS 발송내용 */
                , ""                                      /* SMS 또는 ARS 전송 시 사용할 송신번호 */
                , null                                    /* 이용기관별 추가정보 전달처리시 이용 JSON Object */
            );
        } else if ("telcoAuth-ARSAuth".equals(request.getParameter("serviceType"))) {
            JSONObject extension = new JSONObject();
            extension.put("arsRequestMsg", request.getParameter("arsRequestMsg"));

            MOKAuthRequestJsonString = MOKAuthRequestToJsonString(
                mobileOK
                , MOKAuthRequestJson.getString("publicKey")       /* mok_ars_Gettoken 응답으로 받은 publicKey */
                , MOKAuthRequestJson.getString("encryptMOKToken") /* mok_ars_Gettoken 응답으로 받은 encryptMOKToken */
                , mobileOK.getSiteUrl()                     /* 본인확인-API 등록 사이트 URL */
                , request.getParameter("providerid")        /* 인증 사업자 구분코드 */
                , request.getParameter("reqAuthType")       /* 본인확인 인증 처리 Type 코드 */
                , request.getParameter("usageCode")         /* 서비스 이용 코드 */
                , request.getParameter("serviceType")       /* 이용상품 코드 */
                , request.getParameter("userName")          /* 사용자 이름 */
                , request.getParameter("userPhoneNum")      /* 사용자 전화번호 */
                , request.getParameter("retTransferType")   /* 요청 대상의 결과 전송 타입 */
                , request.getParameter("arsCode")           /* 운영자와 협의 된 ARS 코드 */
                , request.getParameter("userBirthday")    /* 사용자 생년월일 */
                , request.getParameter("userGender")      /* 사용자 성별 */
                , request.getParameter("userNation")      /* 사용자 내외국인 정보 */
                , ""                                        /* SMS 또는 ARS 전송 시 사용할 송신번호 */
                , request.getParameter("replyNumber")       /* ARS 전송 시 사용할 송신번호 */
                , extension                                 /* 이용기관별 추가정보 전달처리시 이용 JSON Object */
            );
        } else if (request.getParameter("serviceType").indexOf("telcoAuth") != -1
                && "SMS".equals(request.getParameter("reqAuthType"))
                || "LMS".equals(request.getParameter("reqAuthType"))) {
            MOKAuthRequestJsonString = MOKAuthRequestToJsonString(
                mobileOK
                , MOKAuthRequestJson.getString("publicKey")       /* MOK_API_Gettoken 응답으로 받은 publicKey */
                , MOKAuthRequestJson.getString("encryptMOKToken") /* MOK_API_Gettoken 응답으로 받은 encryptMOKToken */
                , mobileOK.getSiteUrl()                   /* 본인확인-API 등록 사이트 URL */
                , request.getParameter("providerid")      /* 인증 사업자 구분코드 */
                , request.getParameter("reqAuthType")     /* 본인확인 인증 처리 Type 코드 */
                , request.getParameter("usageCode")       /* 서비스 이용 코드 */
                , request.getParameter("serviceType")     /* 이용상품 코드 */
                , request.getParameter("userName")        /* 사용자 이름 */
                , request.getParameter("userPhoneNum")    /* 사용자 전화번호 */
                , request.getParameter("retTransferType") /* 요청 대상의 결과 전송 타입 */
                , ""                                      /* 운영자와 협의 된 ARS 코드 */
                , request.getParameter("userBirthday")    /* 사용자 생년월일 */
                , request.getParameter("userGender")      /* 사용자 성별 */
                , request.getParameter("userNation")      /* 사용자 내외국인 정보 */
                , request.getParameter("sendMsg")         /* SMS 발송내용 또는 LMS 발송내용 */
                , request.getParameter("replyNumber")     /* SMS 또는 ARS 전송 시 사용할 송신번호 */
                , null                                   /* 이용기관별 추가정보 전달처리시 이용 JSON Object */
            );
        } else if ("SMSAuth".equals(request.getParameter("serviceType"))) {
            MOKAuthRequestJsonString = MOKAuthRequestToJsonString(
                mobileOK
                , MOKAuthRequestJson.getString("publicKey")       /* MOK_API_Gettoken 응답으로 받은 publicKey */
                , MOKAuthRequestJson.getString("encryptMOKToken") /* MOK_API_Gettoken 응답으로 받은 encryptMOKToken */
                , mobileOK.getSiteUrl()                   /* 본인확인-API 등록 사이트 URL */
                , request.getParameter("providerid")      /* 인증 사업자 구분코드 */
                , request.getParameter("reqAuthType")     /* 본인확인 인증 처리 Type 코드 */
                , request.getParameter("usageCode")       /* 서비스 이용 코드 */
                , request.getParameter("serviceType")     /* 이용상품 코드 */
                , request.getParameter("userName")        /* 사용자 이름 */
                , request.getParameter("userPhoneNum")    /* 사용자 전화번호 */
                , request.getParameter("retTransferType") /* 요청 대상의 결과 전송 타입 */
                , ""                                      /* 운영자와 협의 된 ARS 코드 */
                , ""                                      /* 사용자 생년월일 */
                , ""                                      /* 사용자 성별 */
                , ""                                      /* 사용자 내외국인 정보 */
                , request.getParameter("sendMsg")         /* SMS 발송내용 또는 LMS 발송내용 */
                , request.getParameter("replyNumber")     /* SMS 또는 ARS 전송 시 사용할 송신번호 */
                , null                                    /* 이용기관별 추가정보 전달처리시 이용 JSON Object */
            );
        } else {
            return setErrorMsg("인증 사업자 구분코드와 본인확인 인증 처리 Type 코드는 대문자로 입력");
        }

        /* 4. 본인확인 인증요청 */
        String MOKAuthResponseJsonString = sendPost(MOK_REQUEST_URL, MOKAuthRequestJsonString);

        JSONObject MOKAuthResponseJson = new JSONObject(MOKAuthResponseJsonString);

        if (!"2000".equals(MOKAuthResponseJson.getString("resultCode"))) {
            return MOKAuthResponseJson.toString();
        }

        /* 5. 본인확인 검증요청 API에서 이용할 데이터 설정 */
        JSONObject MOKConfirmData = new JSONObject();

        if ("telcoAuth-ARSAuth".equals(request.getParameter("serviceType"))) {
            MOKConfirmData.put("encryptMOKToken", MOKAuthResponseJson.getString("encryptMOKToken"));
            MOKConfirmData.put("resultCode", MOKAuthResponseJson.getString("resultCode"));
            MOKConfirmData.put("resultMsg", MOKAuthResponseJson.getString("resultMsg"));
            MOKConfirmData.put("publicKey", MOKAuthRequestJson.optString("publicKey", null));
            MOKConfirmData.put("arsOtpNumber", MOKAuthResponseJson.optString("arsOtpNumber", null));
        } else {
            MOKConfirmData.put("reqAuthType", request.getParameter("reqAuthType"));
            MOKConfirmData.put("encryptMOKToken", MOKAuthResponseJson.getString("encryptMOKToken"));
            MOKConfirmData.put("resultCode", MOKAuthResponseJson.getString("resultCode"));
            MOKConfirmData.put("resultMsg", MOKAuthResponseJson.getString("resultMsg"));
            MOKConfirmData.put("publicKey", MOKAuthRequestJson.getString("publicKey"));
            MOKConfirmData.put("arsOtpNumber", "");
        }


            /* 5-1. 본인확인 검증요청 입력정보 URLEncoding */
        String MOKConfirmDataString;
        try{
            MOKConfirmDataString = URLEncoder.encode(MOKConfirmData.toString(), "UTF-8");
        } catch (UnsupportedEncodingException e) {
            return setErrorMsg("URLEncoding에 실패했습니다.");
        }

        return MOKConfirmDataString;
    }


    /* 본인확인-API 인증재요청 예제 함수 */
    public String mok_api_auth_resend(String MOKAuthResendData) throws MobileOKException {
        JSONObject MOKAuthResendDataJson = new JSONObject(MOKAuthResendData);

        /* 1. 본인확인 재전송 요청 입력정보 설정 */
        JSONObject MOKAuthResendRequest = new JSONObject();
        MOKAuthResendRequest.put("encryptMOKToken", MOKAuthResendDataJson.getString("encryptMOKToken"));

        /* 2. 본인확인 재전송 요청 */
        String MOKAuthResendResponse = sendPost(MOK_RESEND_URL, MOKAuthResendRequest.toString());

        /* 3. 본인확인 재전송 결과 정보 */
        JSONObject MOKAuthResendResponseJson = new JSONObject(MOKAuthResendResponse);

        /* 4. 본인확인 재전송 실패시 */
        if (!"2000".equals(MOKAuthResendResponseJson.getString("resultCode"))) {
            return MOKAuthResendResponseJson.toString();
        }

        /* 5 본인확인 결과요청 입력 정보 설정 */
        JSONObject MOKConfirmData = new JSONObject();
        MOKConfirmData.put("publicKey", MOKAuthResendDataJson.getString("publicKey"));
        MOKConfirmData.put("encryptMOKToken", MOKAuthResendResponseJson.getString("encryptMOKToken"));
        MOKConfirmData.put("resultCode", MOKAuthResendResponseJson.getString("resultCode"));
        MOKConfirmData.put("resultMsg", MOKAuthResendResponseJson.getString("resultMsg"));

        /* 6 본인확인 결과요청 입력 정보 URLEncoding */
        try{
            return URLEncoder.encode(MOKConfirmData.toString(), "UTF-8");
        } catch (UnsupportedEncodingException e) {
            return setErrorMsg("URLEncoding에 실패했습니다.");
        }
    }


    /* 본인확인-API 인증요청 정보 */
    private String MOKAuthRequestToJsonString(
        mobileOKKeyManager mobileOK
        , String publicKey
        , String encryptMOKToken
        , String siteUrl
        , String providerId
        , String reqAuthType
        , String usageCode
        , String serviceType
        , String userName
        , String userPhoneNum
        , String retTransferType
        , String arsCode
        , String userBirthday
        , String userGender
        , String userNation
        , String sendMsg
        , String replyNumber
        , JSONObject extension) throws MobileOKException {

        JSONObject MOKAuthInfoJson = new JSONObject();
        MOKAuthInfoJson.put("providerId", providerId);
        MOKAuthInfoJson.put("reqAuthType", reqAuthType); 
        MOKAuthInfoJson.put("usageCode", usageCode);           
        MOKAuthInfoJson.put("serviceType", serviceType);
        MOKAuthInfoJson.put("userName", userName);
        MOKAuthInfoJson.put("userPhone", userPhoneNum);
        MOKAuthInfoJson.put("retTransferType", retTransferType);
        if ("telcoAuth-ARSAuth".equals(serviceType)) {
            MOKAuthInfoJson.put("arsCode", arsCode);
            MOKAuthInfoJson.put("userBirthday", userBirthday);
            MOKAuthInfoJson.put("userGender", userGender);
            MOKAuthInfoJson.put("userNation", userNation);
            MOKAuthInfoJson.put("replyNumber", replyNumber);
            MOKAuthInfoJson.put("extension", extension);
        } else if (serviceType.indexOf("telcoAuth") != -1
                && "SMS".equals(reqAuthType)
                || "LMS".equals(reqAuthType)) {
            MOKAuthInfoJson.put("userBirthday", userBirthday);
            MOKAuthInfoJson.put("userGender", userGender);
            MOKAuthInfoJson.put("userNation", userNation);
            if (!"".equals(sendMsg)) {
                MOKAuthInfoJson.put("sendMsg", sendMsg);
            }
            if (!"".equals(replyNumber)) {
                MOKAuthInfoJson.put("replyNumber", replyNumber);
            }
        } else if ("ARSAuth".equals(serviceType)) {
            MOKAuthInfoJson.put("arsCode", arsCode);
            if (!"".equals(sendMsg)) {
                MOKAuthInfoJson.put("sendMsg", sendMsg);
            }
            if (!"".equals(replyNumber)) {
                MOKAuthInfoJson.put("replyNumber", replyNumber);
            }
        } else if ("SMSAuth".equals(serviceType)) {
            if (!"".equals(sendMsg)) {
                MOKAuthInfoJson.put("sendMsg", sendMsg);
            }
            if (!"".equals(replyNumber)) {
                MOKAuthInfoJson.put("replyNumber", replyNumber);
            }
        }

        String encMOKAuthInfo = mobileOK.RSAServerEncrypt(publicKey, MOKAuthInfoJson.toString());

        JSONObject MOKAuthRequestJson = new JSONObject();
        MOKAuthRequestJson.put("siteUrl", siteUrl); 
        MOKAuthRequestJson.put("encryptMOKToken", encryptMOKToken); 
        MOKAuthRequestJson.put("encryptMOKAuthInfo", encMOKAuthInfo); 

        return MOKAuthRequestJson.toString();
    }

    /* 본인확인 서버 통신 예제 함수 */
    private String sendPost(String dest, String jsonData) throws MobileOKException {
        HttpURLConnection connection = null;
        DataOutputStream dataOutputStream = null;
        BufferedReader bufferedReader = null;
        StringBuffer responseData = null;

        try {
            URL url = new URL(dest);
            connection = (HttpURLConnection) url.openConnection();
            connection.setRequestMethod("POST");
            connection.setRequestProperty("Content-Type", "application/json;charset=UTF-8");
            connection.setDoOutput(true);

            dataOutputStream = new DataOutputStream(connection.getOutputStream());
            dataOutputStream.write(jsonData.getBytes("UTF-8"));

            bufferedReader = new BufferedReader(new InputStreamReader(connection.getInputStream()));
            responseData = new StringBuffer();
            String info;
            while ((info = bufferedReader.readLine()) != null) {
                responseData.append(info);
            }

            return responseData.toString();
        } catch (FileNotFoundException e) {
            throw new MobileOKException("MOK_REQUEST_URL 또는 MOK_RESEND_URL을 확인해주세요.");
        } catch (JSONException e) {
            e.printStackTrace();
        } catch(IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (bufferedReader != null) {
                    bufferedReader.close();
                }

                if (dataOutputStream != null) {
                    dataOutputStream.close();
                }

                if (connection != null) {
                    connection.disconnect();
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

        return null;
    }

    private String setErrorMsg(String errorMsg) {
        JSONObject errorJson = new JSONObject();
        errorJson.put("resultMsg", errorMsg);

        return errorJson.toString();
    }
%>

<!DOCTYPE html>
<html>
<head>
    <title>mok_api_auth_request</title>
    <script>
        const MOKAuthRequestJson = decodeURIComponent('<%= resultData %>');
        const MOKAuthRequestJsonObject = JSON.parse(MOKAuthRequestJson);

        document.addEventListener("DOMContentLoaded", function () {
            if (MOKAuthRequestJsonObject.resultCode != '2000') {
                /* 오류발생시 */
                window.alert(MOKAuthRequestJsonObject.resultCode + ', ' + MOKAuthRequestJsonObject.resultMsg);
            } else {
                /* 정장작동시 */
                document.getElementById("MOKConfirmData").value = encodeURIComponent(MOKAuthRequestJson);
                document.getElementById("MOKAuthResendData").value = encodeURIComponent(MOKAuthRequestJson);                
                document.getElementById("MOKCallData").value = encodeURIComponent(MOKAuthRequestJson);
                document.getElementById("arsOtpNumber").innerText = MOKAuthRequestJsonObject.arsOtpNumber;
            }
        });
</script>
</head>
<body>
    <form action='<%= MOK_RESULT_JSP %>' method="post">
        <h1> 인증결과 요청 </h1>
        <input type="hidden" id="MOKConfirmData" name="MOKConfirmData" value='' />

        <h3>인증완료 후 완료버튼을 눌러주세요.</h2>
        <input type="submit" value="완료" style="width:160px; height:30px; margin-right:5px;" />

        <a href='<%= MOK_GET_TOKEN_JSP %>'> 
            <input type="button" style="width:160px; height:30px; margin-left:5px; margin-bottom:15px;" value='취소' />
        </a>
    <!-- 인증방식이 SMS일 경우에만 사용 START -->
    <h3>(인증번호를 수신하는 경우) 인증번호를 입력 후 완료버튼을 눌러주세요.</h3>
    인증번호 : <input type="text" id="authNumber" name="authNumber" value='' style="width: 245px; height: 20px; margin-bottom: 15px;"/> (인증방식 SMS, LMS일 경우 필수) <br>
    <input type="submit" value="완료" style="width:160px; height:30px; margin-right:5px;" />

        <a href='<%= MOK_GET_TOKEN_JSP %>'> 
            <input type="button" style="width:160px; height:30px; margin-left:5px; margin-bottom:15px;" value='취소' />
        </a>
    <!-- 인증방식이 SMS일 경우에만 사용 END -->
    </form>
    <form action="<%= MOK_REQUEST_JSP %>" method="post">
        <input type="hidden" id="MOKAuthResendData" name="MOKAuthResendData" value='' />
        <h3>(재요청은 본인확인 인증 처리 Type 코드가 "SMS"일 경우에만 지원)</h3>
        <button id="resend" name="resend" style="width:335px; height:30px;" >재요청</button>
    </form>
    <!-- 인증방식이 ARS 점유인증일 경우에만 사용 END -->
    <form action='<%= MOK_CALL_JSP %>' method="post">
        <input type="hidden" id="MOKCallData" name="MOKCallData" value='' />     
        <h3>ARS 전화요청 인증번호 (인증번호를 ARS전화요청시 입력하여 주십시오.)</h3>
        <div>인증번호 : <span id="arsOtpNumber"></span></div>
        <input type="submit" value="전화걸기" style="width:160px; height:30px; margin-right:5px;" />
        <a href='<%= MOK_GET_TOKEN_JSP %>'> 
            <input type="button" style="width:160px; height:30px; margin-left:5px; margin-bottom:15px;" value='취소' />
        </a>
    </form>
</body>
</html>
    mok_api_request.jsp
      1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
    <%@page import="java.net.URLDecoder"%>
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<%@ page import="java.net.URL" %>
<%@ page import="java.net.URLEncoder" %>
<%@ page import="java.util.UUID" %>
<%@ page import="java.io.*" %>
<%@ page import="java.io.IOException" %>
<%@ page import="com.dreamsecurity.json.JSONObject" %>
<%@ page import="com.dreamsecurity.json.JSONException" %>
<%@ page import="com.dreamsecurity.mobileOK.mobileOKKeyManager" %>
<%@ page import="com.dreamsecurity.mobileOK.MobileOKException" %>
<%@ page import="javax.net.ssl.SSLContext"%>
<%@ page import="java.security.Security"%>
<%@ page import="java.security.SecureRandom"%>
<%@ page import="org.bouncycastle.jce.provider.BouncyCastleProvider"%>
<%@ page import="org.bouncycastle.jsse.provider.BouncyCastleJsseProvider"%>
<%@ page import="javax.net.ssl.HttpsURLConnection"%>

<%!
    /*1. 본인확인 인증결과 MOKAuth API 또는 MOKResend API 요청 URL*/
    // private final String MOK_REQUEST_URL = "https://cert-dir.mobile-ok.com/agent/v1/auth/request";   // 운영
    private final String MOK_REQUEST_URL = "https://scert-dir.mobile-ok.com/agent/v1/auth/request";  // 개발
    // private final String MOK_RESEND_URL = "https://cert-dir.mobile-ok.com/agent/v1/auth/resend";        //운영
    private final String MOK_RESEND_URL = "https://scert-dir.mobile-ok.com/agent/v1/auth/resend";        // 개발

    /* 완료 버튼 클릭시 이동 JSP (mobileOK-Result JSP)*/
    private final String MOK_RESULT_JSP = "./mok_api_result.jsp";
    /* 취소 버튼 클릭시 이동 JSP (mobileOK-GetToken JSP)*/
    private final String MOK_GET_TOKEN_JSP = "./mok_api_gettoken.jsp";
    /* 재전송 버튼 클릭시 이동 JSP (mobileOK-Request JSP)*/
    private final String MOK_REQUEST_JSP = "./mok_api_request.jsp";
    /* 전화걸기 버튼 클릭시 이동 JSP (mobileOK-CALL JSP) => ARS일 경우*/
    private final String MOK_CALL_JSP = "./mok_ars_call.jsp";
%>

<%
    if (Security.getProvider(BouncyCastleProvider.PROVIDER_NAME) == null) {
        Security.addProvider(new BouncyCastleProvider());
        Security.addProvider(new BouncyCastleJsseProvider());
        System.setProperty("jdk.tls.trustNameService", "true");
    }

    request.setCharacterEncoding("utf-8");
    /*2. 본인확인 서비스 API 초기화*/
    mobileOKKeyManager mobileOK = new mobileOKKeyManager();
    /* 키파일은 반드시 서버의 안전한 로컬경로에 별도 저장. 웹URL 경로에 파일이 있을경우 키파일이 외부에 노출될 수 있음 주의 */
    mobileOK.keyInit("/본인확인-API 키정보파일 Path/mok_keyInfo.dat", "키파일 패스워드");
    mobileOK.setSiteUrl("본인확인-API 등록 사이트 URL");

    // 재전송 여부 확인용
    String resendData = request.getParameter("MOKAuthResendData");
    // 정상요청 여부 확인용
    String normalFlag = request.getParameter("normalFlag");
    // 재시도 여부 확인용
    String retryData = request.getParameter("MOKConfirmRetryData");

    /* 2-1. 현재 페이지의 요청 정보 (정상요청 / 재전송 요청 / 비정상적인 요청)에 따른 실행 */
    String resultData = "";
    if ("Y".equals(normalFlag)) {
        System.out.println("정상요청 (Auth Request)");
        resultData = mobileOK_api_auth_request(mobileOK, request);
    } else if (!"".equals(resendData) && resendData != null) {
        System.out.println("재전송 요청 (resend)");
        try {
            resendData = URLDecoder.decode(resendData, "UTF-8");
        } catch(UnsupportedEncodingException e) {
            resultData = setErrorMsg("URLDecoding에 실패했습니다.");
        }
        resultData = mok_api_auth_resend(resendData);
    } else if (!"".equals(retryData) && retryData != null) {
        System.out.println("검증 재시도 (Confirm Retry)");
        try {
            retryData = URLDecoder.decode(retryData, "UTF-8");
        } catch(UnsupportedEncodingException e) {
            resultData = setErrorMsg("URLDecoding에 실패했습니다.");
        }

        JSONObject retryDataJson = new JSONObject(retryData);
        retryDataJson.put("resultCode", "2000");  // 재시도 요청에 성공했을 경우

        try{
            resultData = URLEncoder.encode(retryDataJson.toString(), "UTF-8");
        } catch (UnsupportedEncodingException e) {
            setErrorMsg("URLEncoding에 실패했습니다.");
        }

    } else {
        resultData = setErrorMsg("올바르지 않는 인증 사업자 구분코드 또는 본인확인 인증 처리 Type 입니다.");
    }
%>

<%!
    /* 본인확인-API 인증요청 예제 함수 */
    public String mobileOK_api_auth_request(mobileOKKeyManager mobileOK, HttpServletRequest request) throws MobileOKException {

        String MOKAuthRequestData = request.getParameter("MOKAuthRequestData");
        JSONObject MOKAuthRequestJson = new JSONObject(MOKAuthRequestData);

        /* 3. 본인확인 인증요청 입력정보 설정 (아래 MOKAuthInfoToJson() 참조) */
        String MOKAuthRequestJsonString = "";
        if ("PASS".equals(request.getParameter("reqAuthType"))){
            MOKAuthRequestJsonString = MOKAuthRequestToJsonString(
                mobileOK
                , MOKAuthRequestJson.getString("publicKey")       /* MOK_API_Gettoken 응답으로 받은 publicKey */
                , MOKAuthRequestJson.getString("encryptMOKToken") /* MOK_API_Gettoken 응답으로 받은 encryptMOKToken */
                , mobileOK.getSiteUrl()                   /* 본인확인-API 등록 사이트 URL */
                , request.getParameter("providerid")      /* 인증 사업자 구분코드 */
                , request.getParameter("reqAuthType")     /* 본인확인 인증 처리 Type 코드 */
                , request.getParameter("usageCode")       /* 서비스 이용 코드 */
                , request.getParameter("serviceType")     /* 이용상품 코드 */
                , request.getParameter("userName")        /* 사용자 이름 */
                , request.getParameter("userPhoneNum")    /* 사용자 전화번호 */
                , request.getParameter("retTransferType") /* 요청 대상의 결과 전송 타입 */
                , ""                                      /* 운영자와 협의 된 ARS 코드 */
                , ""                                      /* 사용자 생년월일 */
                , ""                                      /* 사용자 성별 */
                , ""                                      /* 사용자 내외국인 정보 */
                , ""                                      /* SMS 발송내용 또는 LMS 발송내용 */
                , ""                                      /* SMS 또는 ARS 전송 시 사용할 송신번호 */
                , null                                    /* 이용기관별 추가정보 전달처리시 이용 JSON Object */
            );
        } else if ("telcoAuth-ARSAuth".equals(request.getParameter("serviceType"))) {
            JSONObject extension = new JSONObject();
            extension.put("arsRequestMsg", request.getParameter("arsRequestMsg"));

            MOKAuthRequestJsonString = MOKAuthRequestToJsonString(
                mobileOK
                , MOKAuthRequestJson.getString("publicKey")       /* mok_ars_Gettoken 응답으로 받은 publicKey */
                , MOKAuthRequestJson.getString("encryptMOKToken") /* mok_ars_Gettoken 응답으로 받은 encryptMOKToken */
                , mobileOK.getSiteUrl()                     /* 본인확인-API 등록 사이트 URL */
                , request.getParameter("providerid")        /* 인증 사업자 구분코드 */
                , request.getParameter("reqAuthType")       /* 본인확인 인증 처리 Type 코드 */
                , request.getParameter("usageCode")         /* 서비스 이용 코드 */
                , request.getParameter("serviceType")       /* 이용상품 코드 */
                , request.getParameter("userName")          /* 사용자 이름 */
                , request.getParameter("userPhoneNum")      /* 사용자 전화번호 */
                , request.getParameter("retTransferType")   /* 요청 대상의 결과 전송 타입 */
                , request.getParameter("arsCode")           /* 운영자와 협의 된 ARS 코드 */
                , request.getParameter("userBirthday")    /* 사용자 생년월일 */
                , request.getParameter("userGender")      /* 사용자 성별 */
                , request.getParameter("userNation")      /* 사용자 내외국인 정보 */
                , ""                                        /* SMS 또는 ARS 전송 시 사용할 송신번호 */
                , request.getParameter("replyNumber")       /* ARS 전송 시 사용할 송신번호 */
                , extension                                 /* 이용기관별 추가정보 전달처리시 이용 JSON Object */
            );
        } else if (request.getParameter("serviceType").indexOf("telcoAuth") != -1
                && "SMS".equals(request.getParameter("reqAuthType"))
                || "LMS".equals(request.getParameter("reqAuthType"))) {
            MOKAuthRequestJsonString = MOKAuthRequestToJsonString(
                mobileOK
                , MOKAuthRequestJson.getString("publicKey")       /* MOK_API_Gettoken 응답으로 받은 publicKey */
                , MOKAuthRequestJson.getString("encryptMOKToken") /* MOK_API_Gettoken 응답으로 받은 encryptMOKToken */
                , mobileOK.getSiteUrl()                   /* 본인확인-API 등록 사이트 URL */
                , request.getParameter("providerid")      /* 인증 사업자 구분코드 */
                , request.getParameter("reqAuthType")     /* 본인확인 인증 처리 Type 코드 */
                , request.getParameter("usageCode")       /* 서비스 이용 코드 */
                , request.getParameter("serviceType")     /* 이용상품 코드 */
                , request.getParameter("userName")        /* 사용자 이름 */
                , request.getParameter("userPhoneNum")    /* 사용자 전화번호 */
                , request.getParameter("retTransferType") /* 요청 대상의 결과 전송 타입 */
                , ""                                      /* 운영자와 협의 된 ARS 코드 */
                , request.getParameter("userBirthday")    /* 사용자 생년월일 */
                , request.getParameter("userGender")      /* 사용자 성별 */
                , request.getParameter("userNation")      /* 사용자 내외국인 정보 */
                , request.getParameter("sendMsg")         /* SMS 발송내용 또는 LMS 발송내용 */
                , request.getParameter("replyNumber")     /* SMS 또는 ARS 전송 시 사용할 송신번호 */
                , null                                    /* 이용기관별 추가정보 전달처리시 이용 JSON Object */
            );
        } else if ("SMSAuth".equals(request.getParameter("serviceType"))) {
            MOKAuthRequestJsonString = MOKAuthRequestToJsonString(
                mobileOK
                , MOKAuthRequestJson.getString("publicKey")       /* MOK_API_Gettoken 응답으로 받은 publicKey */
                , MOKAuthRequestJson.getString("encryptMOKToken") /* MOK_API_Gettoken 응답으로 받은 encryptMOKToken */
                , mobileOK.getSiteUrl()                   /* 본인확인-API 등록 사이트 URL */
                , request.getParameter("providerid")      /* 인증 사업자 구분코드 */
                , request.getParameter("reqAuthType")     /* 본인확인 인증 처리 Type 코드 */
                , request.getParameter("usageCode")       /* 서비스 이용 코드 */
                , request.getParameter("serviceType")     /* 이용상품 코드 */
                , request.getParameter("userName")        /* 사용자 이름 */
                , request.getParameter("userPhoneNum")    /* 사용자 전화번호 */
                , request.getParameter("retTransferType") /* 요청 대상의 결과 전송 타입 */
                , ""                                      /* 운영자와 협의 된 ARS 코드 */
                , ""                                      /* 사용자 생년월일 */
                , ""                                      /* 사용자 성별 */
                , ""                                      /* 사용자 내외국인 정보 */
                , request.getParameter("sendMsg")         /* SMS 발송내용 또는 LMS 발송내용 */
                , request.getParameter("replyNumber")     /* SMS 또는 ARS 전송 시 사용할 송신번호 */
                , null                                    /* 이용기관별 추가정보 전달처리시 이용 JSON Object */
            );
        } else {
            return setErrorMsg("인증 사업자 구분코드와 본인확인 인증 처리 Type 코드는 대문자로 입력");
        }

        /* 4. 본인확인 인증요청 */
        String MOKAuthResponseJsonString = sendPost(MOK_REQUEST_URL, MOKAuthRequestJsonString);

        JSONObject MOKAuthResponseJson = new JSONObject(MOKAuthResponseJsonString);

        if (!"2000".equals(MOKAuthResponseJson.getString("resultCode"))) {
            return MOKAuthResponseJson.toString();
        }

        /* 5. 본인확인 검증요청 API에서 이용할 데이터 설정 */
        JSONObject MOKConfirmData = new JSONObject();

    if ("telcoAuth-ARSAuth".equals(request.getParameter("serviceType"))) {
            MOKConfirmData.put("encryptMOKToken", MOKAuthResponseJson.getString("encryptMOKToken"));
            MOKConfirmData.put("resultCode", MOKAuthResponseJson.getString("resultCode"));
            MOKConfirmData.put("resultMsg", MOKAuthResponseJson.getString("resultMsg"));
            MOKConfirmData.put("publicKey", MOKAuthRequestJson.optString("publicKey", null));
            MOKConfirmData.put("arsOtpNumber", MOKAuthResponseJson.optString("arsOtpNumber", null));
        } else {
            MOKConfirmData.put("reqAuthType", request.getParameter("reqAuthType"));
            MOKConfirmData.put("encryptMOKToken", MOKAuthResponseJson.getString("encryptMOKToken"));
            MOKConfirmData.put("resultCode", MOKAuthResponseJson.getString("resultCode"));
            MOKConfirmData.put("resultMsg", MOKAuthResponseJson.getString("resultMsg"));
            MOKConfirmData.put("publicKey", MOKAuthRequestJson.getString("publicKey"));
            MOKConfirmData.put("arsOtpNumber", "");
        }

            /* 5-1. 본인확인 검증요청 입력정보 URLEncoding */
        String MOKConfirmDataString;
        try{
            MOKConfirmDataString = URLEncoder.encode(MOKConfirmData.toString(), "UTF-8");
        } catch (UnsupportedEncodingException e) {
            return setErrorMsg("URLEncoding에 실패했습니다.");
        }

        return MOKConfirmDataString;
    }


    /* 본인확인-API 인증재요청 예제 함수 */
    public String mok_api_auth_resend(String MOKAuthResendData) throws MobileOKException {
        JSONObject MOKAuthResendDataJson = new JSONObject(MOKAuthResendData);

        /* 1. 본인확인 재전송 요청 입력정보 설정 */
        JSONObject MOKAuthResendRequest = new JSONObject();
        MOKAuthResendRequest.put("encryptMOKToken", MOKAuthResendDataJson.getString("encryptMOKToken"));

        /* 2. 본인확인 재전송 요청 */
        String MOKAuthResendResponse = sendPost(MOK_RESEND_URL, MOKAuthResendRequest.toString());

        /* 3. 본인확인 재전송 결과 정보 */
        JSONObject MOKAuthResendResponseJson = new JSONObject(MOKAuthResendResponse);

        /* 4. 본인확인 재전송 실패시 */
        if (!"2000".equals(MOKAuthResendResponseJson.getString("resultCode"))) {
            return MOKAuthResendResponseJson.toString();
        }

        /* 5 본인확인 결과요청 입력 정보 설정 */
        JSONObject MOKConfirmData = new JSONObject();
        MOKConfirmData.put("reqAuthType", MOKAuthResendDataJson.getString("reqAuthType"));
        MOKConfirmData.put("publicKey", MOKAuthResendDataJson.getString("publicKey"));
        MOKConfirmData.put("encryptMOKToken", MOKAuthResendResponseJson.getString("encryptMOKToken"));
        MOKConfirmData.put("resultCode", MOKAuthResendResponseJson.getString("resultCode"));
        MOKConfirmData.put("resultMsg", MOKAuthResendResponseJson.getString("resultMsg"));

        /* 6 본인확인 결과요청 입력 정보 URLEncoding */
        try{
            return URLEncoder.encode(MOKConfirmData.toString(), "UTF-8");
        } catch (UnsupportedEncodingException e) {
            return setErrorMsg("URLEncoding에 실패했습니다.");
        }
    }


    /* 본인확인-API 인증요청 정보 */
    private String MOKAuthRequestToJsonString(
        mobileOKKeyManager mobileOK
        , String publicKey
        , String encryptMOKToken
        , String siteUrl
        , String providerId
        , String reqAuthType
        , String usageCode
        , String serviceType
        , String userName
        , String userPhoneNum
        , String retTransferType
        , String arsCode
        , String userBirthday
        , String userGender
        , String userNation
        , String sendMsg
        , String replyNumber
        , JSONObject extension) throws MobileOKException {

        JSONObject MOKAuthInfoJson = new JSONObject();
        MOKAuthInfoJson.put("providerId", providerId);
        MOKAuthInfoJson.put("reqAuthType", reqAuthType); 
        MOKAuthInfoJson.put("usageCode", usageCode);           
        MOKAuthInfoJson.put("serviceType", serviceType);
        MOKAuthInfoJson.put("userName", userName);
        MOKAuthInfoJson.put("userPhone", userPhoneNum);
        MOKAuthInfoJson.put("retTransferType", retTransferType);
        if ("telcoAuth-ARSAuth".equals(serviceType)) {
            MOKAuthInfoJson.put("arsCode", arsCode);
            MOKAuthInfoJson.put("userBirthday", userBirthday);
            MOKAuthInfoJson.put("userGender", userGender);
            MOKAuthInfoJson.put("userNation", userNation);
            MOKAuthInfoJson.put("replyNumber", replyNumber);
            MOKAuthInfoJson.put("extension", extension);
        } else if (serviceType.indexOf("telcoAuth") != -1
                && "SMS".equals(reqAuthType)
                || "LMS".equals(reqAuthType)) {
            MOKAuthInfoJson.put("userBirthday", userBirthday);
            MOKAuthInfoJson.put("userGender", userGender);
            MOKAuthInfoJson.put("userNation", userNation);
            if (!"".equals(sendMsg)) {
                MOKAuthInfoJson.put("sendMsg", sendMsg);
            }
            if (!"".equals(replyNumber)) {
                MOKAuthInfoJson.put("replyNumber", replyNumber);
            }
        } else if ("ARSAuth".equals(serviceType)) {
            MOKAuthInfoJson.put("arsCode", arsCode);
            if (!"".equals(sendMsg)) {
                MOKAuthInfoJson.put("sendMsg", sendMsg);
            }
            if (!"".equals(replyNumber)) {
                MOKAuthInfoJson.put("replyNumber", replyNumber);
            }
        } else if ("SMSAuth".equals(serviceType)) {
            if (!"".equals(sendMsg)) {
                MOKAuthInfoJson.put("sendMsg", sendMsg);
            }
            if (!"".equals(replyNumber)) {
                MOKAuthInfoJson.put("replyNumber", replyNumber);
            }
        } 

        String encMOKAuthInfo = mobileOK.RSAServerEncrypt(publicKey, MOKAuthInfoJson.toString());

        JSONObject MOKAuthRequestJson = new JSONObject();
        MOKAuthRequestJson.put("siteUrl", siteUrl); 
        MOKAuthRequestJson.put("encryptMOKToken", encryptMOKToken); 
        MOKAuthRequestJson.put("encryptMOKAuthInfo", encMOKAuthInfo); 

        return MOKAuthRequestJson.toString();
    }

    /* 본인확인 서버 통신 예제 함수 */
    private String sendPost(String dest, String jsonData) throws MobileOKException {
        HttpsURLConnection connection = null;
        DataOutputStream dataOutputStream = null;
        BufferedReader bufferedReader = null;
        StringBuffer responseData = null;

        try {
            SSLContext sslContext = SSLContext.getInstance("TLSv1.2", new BouncyCastleJsseProvider());
            sslContext.init(null, null, new SecureRandom());

            URL url = new URL(dest);
            connection = (HttpsURLConnection) url.openConnection();
            connection.setSSLSocketFactory(sslContext.getSocketFactory());

            connection.setRequestMethod("POST");
            connection.setRequestProperty("Content-Type", "application/json;charset=UTF-8");
            connection.setDoOutput(true);

            dataOutputStream = new DataOutputStream(connection.getOutputStream());
            dataOutputStream.write(jsonData.getBytes("UTF-8"));

            bufferedReader = new BufferedReader(new InputStreamReader(connection.getInputStream()));
            responseData = new StringBuffer();
            String info;
            while ((info = bufferedReader.readLine()) != null) {
                responseData.append(info);
            }

            return responseData.toString();
        } catch (FileNotFoundException e) {
            throw new MobileOKException("MOK_REQUEST_URL 또는 MOK_RESEND_URL을 확인해주세요.");
        } catch (JSONException e) {
            e.printStackTrace();
        } catch(IOException e) {
            e.printStackTrace();
        } catch(Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (bufferedReader != null) {
                    bufferedReader.close();
                }

                if (dataOutputStream != null) {
                    dataOutputStream.close();
                }

                if (connection != null) {
                    connection.disconnect();
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

        return null;
    }

    private String setErrorMsg(String errorMsg) {
        JSONObject errorJson = new JSONObject();
        errorJson.put("resultMsg", errorMsg);

        return errorJson.toString();
    }
%>

<!DOCTYPE html>
<html>
<head>
    <title>mok_api_auth_request</title>
    <script>
        const MOKAuthRequestJson = decodeURIComponent('<%= resultData %>');
        const MOKAuthRequestJsonObject = JSON.parse(MOKAuthRequestJson);

        document.addEventListener("DOMContentLoaded", function () {
            if (MOKAuthRequestJsonObject.resultCode != '2000') {
                /* 오류발생시 */
                window.alert(MOKAuthRequestJsonObject.resultCode + ', ' + MOKAuthRequestJsonObject.resultMsg);
            } else {
                /* 정장작동시 */
                document.getElementById("MOKConfirmData").value = encodeURIComponent(MOKAuthRequestJson);
                document.getElementById("MOKAuthResendData").value = encodeURIComponent(MOKAuthRequestJson);
        document.getElementById("MOKCallData").value = encodeURIComponent(MOKAuthRequestJson);
                document.getElementById("arsOtpNumber").innerText = MOKAuthRequestJsonObject.arsOtpNumber;
            }
        });
    </script>
</head>
<body>
    <form action='<%= MOK_RESULT_JSP %>' method="post">
        <h1> 인증결과 요청 </h1>
        <input type="hidden" id="MOKConfirmData" name="MOKConfirmData" value='' />

        <h3>인증완료 후 완료버튼을 눌러주세요.</h2>
        <input type="submit" value="완료" style="width:160px; height:30px; margin-right:5px;" />

        <a href='<%= MOK_GET_TOKEN_JSP %>'> 
            <input type="button" style="width:160px; height:30px; margin-left:5px; margin-bottom:15px;" value='취소' />
        </a>
    <!-- 인증방식이 SMS일 경우에만 사용 START -->
    <h3>(인증번호를 수신하는 경우) 인증번호를 입력 후 완료버튼을 눌러주세요.</h3>
    인증번호 : <input type="text" id="authNumber" name="authNumber" value='' style="width: 245px; height: 20px; margin-bottom: 15px;"/> (인증방식 SMS, LMS일 경우 필수) <br>
    <input type="submit" value="완료" style="width:160px; height:30px; margin-right:5px;" />

        <a href='<%= MOK_GET_TOKEN_JSP %>'> 
            <input type="button" style="width:160px; height:30px; margin-left:5px; margin-bottom:15px;" value='취소' />
        </a>
    <!-- 인증방식이 SMS일 경우에만 사용 END -->
    </form>
    <form action="<%= MOK_REQUEST_JSP %>" method="post">
        <input type="hidden" id="MOKAuthResendData" name="MOKAuthResendData" value='' />
        <h3>(재요청은 본인확인 인증 처리 Type 코드가 "SMS"일 경우에만 지원)</h3>
        <button id="resend" name="resend" style="width:335px; height:30px;" >재요청</button>
    </form>
    <!-- 인증방식이 ARS 점유인증일 경우에만 사용 END -->
    <form action='<%= MOK_CALL_JSP %>' method="post">
        <input type="hidden" id="MOKCallData" name="MOKCallData" value='' />     
        <h3>ARS 전화요청 인증번호 (인증번호를 ARS전화요청시 입력하여 주십시오.)</h3>
        <div>인증번호 : <span id="arsOtpNumber"></span></div>
        <input type="submit" value="전화걸기" style="width:160px; height:30px; margin-right:5px;" />
        <a href='<%= MOK_GET_TOKEN_JSP %>'> 
            <input type="button" style="width:160px; height:30px; margin-left:5px; margin-bottom:15px;" value='취소' />
        </a>
    </form>
</body>
</html>
    mok_api_request.php
      1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
    <?php
    // 각 버전 별 맞는 mobileOKManager-php를 사용
    $mobileOK_path = "./mobileOK_manager_phpseclib_v3.0_v1.0.2.php";

    if(!file_exists($mobileOK_path)) {
        die('1000|mobileOK_Key_Manager파일이 존재하지 않습니다.');
    } else {
        require_once $mobileOK_path;
    }
?>
<?php
    // local시간 설정이 다르게 될  수 있음으로 기본 시간 설정을 서울로 해놓는다.
    date_default_timezone_set('Asia/Seoul');
?>
<?php
    /* 1. 본인확인 인증결과 MOKAuth API 또는 MOKResend API 요청 URL */
    $MOK_REQUEST_URL = "https://scert-dir.mobile-ok.com/agent/v1/auth/request"; // 개발
    // $MOK_REQUEST_URL = "https://cert-dir.mobile-ok.com/agent/v1/auth/request"; // 운영
    $MOK_RESEND_URL = "https://scert-dir.mobile-ok.com/agent/v1/auth/resend";     // 개발
    // $MOK_RESEND_URL = "https://cert-dir.mobile-ok.com/agent/v1/auth/resend";   // 운영

    /* 완료 버튼 클릭시 이동 PHP (mobileOK-Result PHP)*/
    $MOK_API_RESULT_PHP = "./mok_api_result.php";
    /* 취소 버튼 클릭시 이동 PHP (mobileOK-GetToken PHP)*/
    $MOK_API_GET_TOKEN_PHP = "./mok_api_gettoken.php";
    /* 재전송 버튼 클릭시 이동 PHP (mobileOK-Request PHP)*/
    $MOK_API_REQUEST_PHP = "./mok_api_request.php";
    /* 완료 버튼 클릭시 이동 PHP (mobileOK-CALL PHP) => ARS일 경우*/
    $MOK_API_CALL_PHP = "./mok_ars_call.php";

    /* 2. 본인확인 서비스 API 초기화 */
    $mobileOK = new mobileOK_Key_Manager();
    /* 본인확인 키파일은 반드시 서버의 안전한 로컬경로에 별도 저장. 웹URL 경로에 파일이 있을경우 키파일이 외부에 노출될 수 있음 주의 */
    $key_path = "/본인확인-API 키정보파일 Path/mok_keyInfo.dat";
    $password = "키파일 패스워드";
    $mobileOK->key_init($key_path, $password);
    $mobileOK->set_site_url("본인확인-API 등록 사이트 URL");

    if (isset($_POST['normalFlag'])) { 
        $MOK_AUTH_REQUEST_RESULT = mobileOK_api_auth_request($mobileOK, $MOK_REQUEST_URL);
    } else if (isset($_POST['MOKAuthResendData'])) {
        $MOK_AUTH_REQUEST_RESULT = mobileOK_api_auth_resend($_POST['MOKAuthResendData'], $MOK_RESEND_URL);
    } else if (isset($_POST['MOKConfirmRetryData'])) {
        $MOK_confirm_retry_data = json_decode($_POST['MOKConfirmRetryData']);
        $MOK_confirm_retry_data -> resultCode = "2000";
        $MOK_AUTH_REQUEST_RESULT = json_encode($MOK_confirm_retry_data);
    } else {
        $error_data = array(
            'resultMsg' => '올바르지 않는 인증 사업자 구분코드 또는 본인확인 인증 처리 Type 입니다.'
        );

        $MOK_AUTH_REQUEST_RESULT = json_encode($error_data, JSON_UNESCAPED_SLASHES);
    }
?>

<?php
    /* 본인확인 API 인증요청 예제 함수 */
    function mobileOK_api_auth_request($mobileOK, $MOK_REQUEST_URL) {
        $MOK_auth_request_data = json_decode($_POST['MOKAuthRequestData']);

        /* 3. 본인확인 인증요청 입력정보 설정 (아래 MOKAuthInfoToJson() 참조) */
        $MOK_auth_request_json_string = '';
        if ('PASS' == $_POST['reqAuthType']) {
            $MOK_auth_request_json_string = MOKAuthRequestToJsonString(
                $mobileOK
                , $MOK_auth_request_data->publicKey       /* MOK_API_Gettoken 응답으로 받은 publicKey */
                , $MOK_auth_request_data->encryptMOKToken /* MOK_API_Gettoken 응답으로 받은 encryptMOKToken */
                , $mobileOK->get_site_url()  /* 본인확인-API 등록 사이트 URL */
                , $_POST['providerid']       /* 인증 사업자 구분코드 */
                , $_POST['reqAuthType']      /* 본인확인 인증 처리 Type 코드 */
                , $_POST['usageCode']        /* 서비스 이용 코드 */
                , $_POST['serviceType']      /* 이용상품 코드 */
                , $_POST['userName']         /* 사용자 이름 */
                , $_POST['userPhoneNum']     /* 사용자 전화번호 */
                , $_POST['retTransferType']  /* 요청 대상의 결과 전송 타입 */
                , ''                         /* 운영자와 협의 된 ARS 코드 */
                , ''                         /* 사용자 생년월일 */
                , ''                         /* 사용자 성별 */
                , ''                         /* 사용자 내외국인 정보 */
                , ''                         /* SMS 발송내용 또는 LMS 발송내용 */
                , ''                         /* SMS 발송번호 */
                , null                       /* 이용기관별 추가정보 전달처리시 이용 JSON Object */
            );
        } else if ('telcoAuth-ARSAuth' == $_POST['serviceType']) {
            $extension = array("arsRequestMsg" => $_POST['arsRequestMsg']);

            $MOK_auth_request_json_string = MOKAuthRequestToJsonString(
                $mobileOK
                , $MOK_auth_request_data->publicKey       /* MOK_API_Gettoken 응답으로 받은 publicKey */
                , $MOK_auth_request_data->encryptMOKToken /* MOK_API_Gettoken 응답으로 받은 encryptMOKToken */
                , $mobileOK->get_site_url()  /* 본인확인-API 등록 사이트 URL */
                , $_POST['providerid']       /* 인증 사업자 구분코드 */
                , $_POST['reqAuthType']      /* 본인확인 인증 처리 Type 코드 */
                , $_POST['usageCode']        /* 서비스 이용 코드 */
                , $_POST['serviceType']      /* 이용상품 코드 */
                , $_POST['userName']         /* 사용자 이름 */
                , $_POST['userPhoneNum']     /* 사용자 전화번호 */
                , $_POST['retTransferType']  /* 요청 대상의 결과 전송 타입 */
                , $_POST['arsCode']          /* 운영자와 협의 된 ARS 코드 */
                , $_POST['userBirthday']     /* 사용자 생년월일 */
                , $_POST['userGender']       /* 사용자 성별 */
                , $_POST['userNation']       /* 사용자 내외국인 정보 */
                , $_POST['sendMsg']          /* SMS 발송내용 또는 LMS 발송내용 */
                , $_POST['replyNumber']      /* SMS 발송번호 */
                , $extension                 /* 이용기관별 추가정보 전달처리시 이용 JSON Object */
            );
        } else if (strpos($_POST['serviceType'], 'telcoAuth') !== false
                && 'SMS' == $_POST['reqAuthType']
                || 'LMS' == $_POST['reqAuthType']) {
            $MOK_auth_request_json_string = MOKAuthRequestToJsonString(
                $mobileOK
                , $MOK_auth_request_data->publicKey       /* MOK_API_Gettoken 응답으로 받은 publicKey */
                , $MOK_auth_request_data->encryptMOKToken /* MOK_API_Gettoken 응답으로 받은 encryptMOKToken */
                , $mobileOK->get_site_url()  /* 본인확인-API 등록 사이트 URL */
                , $_POST['providerid']       /* 인증 사업자 구분코드 */
                , $_POST['reqAuthType']      /* 본인확인 인증 처리 Type 코드 */
                , $_POST['usageCode']        /* 서비스 이용 코드 */
                , $_POST['serviceType']      /* 이용상품 코드 */
                , $_POST['userName']         /* 사용자 이름 */
                , $_POST['userPhoneNum']     /* 사용자 전화번호 */
                , $_POST['retTransferType']  /* 요청 대상의 결과 전송 타입 */
                , ''                         /* 운영자와 협의 된 ARS 코드 */
                , $_POST['userBirthday']     /* 사용자 생년월일 */
                , $_POST['userGender']       /* 사용자 성별 */
                , $_POST['userNation']       /* 사용자 내외국인 정보 */
                , $_POST['sendMsg']          /* SMS 발송내용 또는 LMS 발송내용 */
                , $_POST['replyNumber']      /* SMS 발송번호 */
                , null                       /* 이용기관별 추가정보 전달처리시 이용 JSON Object */
            );
        } else if ('SMSAuth' == $_POST['serviceType']) {
            $MOK_auth_request_json_string = MOKAuthRequestToJsonString(
                $mobileOK
                , $MOK_auth_request_data->publicKey       /* MOK_API_Gettoken 응답으로 받은 publicKey */
                , $MOK_auth_request_data->encryptMOKToken /* MOK_API_Gettoken 응답으로 받은 encryptMOKToken */
                , $mobileOK->get_site_url()  /* 본인확인-API 등록 사이트 URL */
                , $_POST['providerid']       /* 인증 사업자 구분코드 */
                , $_POST['reqAuthType']      /* 본인확인 인증 처리 Type 코드 */
                , $_POST['usageCode']        /* 서비스 이용 코드 */
                , $_POST['serviceType']      /* 이용상품 코드 */
                , $_POST['userName']         /* 사용자 이름 */
                , $_POST['userPhoneNum']     /* 사용자 전화번호 */
                , $_POST['retTransferType']  /* 요청 대상의 결과 전송 타입 */
                , ''                         /* 운영자와 협의 된 ARS 코드 */
                , ''                         /* 사용자 생년월일 */
                , ''                         /* 사용자 성별 */
                , ''                         /* 사용자 내외국인 정보 */
                , $_POST['sendMsg']          /* SMS 발송내용 또는 LMS 발송내용 */
                , $_POST['replyNumber']      /* SMS 발송번호 */
                , null                       /* 이용기관별 추가정보 전달처리시 이용 JSON Object */
            );
        } else {
            $error_data = array(
                'resultMsg' => '지정된 인증 사업자 구분코드(reqAuthType) 또는 이용상품 코드(serviceType)이 아닙니다.'
            );

            $MOK_AUTH_REQUEST_RESULT = json_encode($error_data, JSON_UNESCAPED_SLASHES);
        }

        /* 4. 본인확인 인증요청 */
        $MOK_auth_response_json = sendPost($MOK_auth_request_json_string, $MOK_REQUEST_URL);
        $MOK_auth_response_array = json_decode($MOK_auth_response_json);

        /* 5. 본인확인 검증요청 API에서 이용할 데이터 설정 */
        if('telcoAuth-ARSAuth' == $_POST['serviceType']){
            $MOK_confirm_data = array(
                'encryptMOKToken' => $MOK_auth_response_array->encryptMOKToken
                , 'publicKey' => $MOK_auth_request_data->publicKey
                , 'resultCode' => $MOK_auth_response_array->resultCode
                , 'resultMsg' => $MOK_auth_response_array->resultMsg
                , 'arsOtpNumber' => $MOK_auth_response_array->arsOtpNumber
            );
        } else {
            $MOK_confirm_data = array(
                'encryptMOKToken' => $MOK_auth_response_array->encryptMOKToken
                , 'publicKey' => $MOK_auth_request_data->publicKey
                , 'resultCode' => $MOK_auth_response_array->resultCode
                , 'resultMsg' => $MOK_auth_response_array->resultMsg
                , 'arsOtpNumber' => ''
            );
        }

        return json_encode($MOK_confirm_data, JSON_UNESCAPED_SLASHES);
    }

    /* 본인확인-API 인증재요청 예제 함수 */
    function mobileOK_api_auth_resend($MOK_auth_resend_data, $MOK_RESEND_URL) {
        $MOK_auth_resend_data_array = json_decode($MOK_auth_resend_data);

        /* 1. 본인확인 재전송 요청 입력정보 설정 */
        $MOK_auth_resend_request_array = array(
            'encryptMOKToken' => $MOK_auth_resend_data_array->encryptMOKToken
        );
        $MOK_auth_resend_request_json = json_encode($MOK_auth_resend_request_array);

        /* 2. 본인확인 재전송 요청 */
        $MOK_auth_resend_response_json = sendPost($MOK_auth_resend_request_json, $MOK_RESEND_URL);

        /* 3. 본인확인 재전송 결과 정보 */
        $MOK_auth_resend_response_array = json_decode($MOK_auth_resend_response_json);

        /* 4. 본인확인 재전송 실패시 */
        if ($MOK_auth_resend_response_array->resultCode != '2000') {
            return json_encode($MOK_auth_resend_response_array);
        }

        /* 5 본인확인 결과요청 입력 정보 설정 */
        $MOK_confirm_data = array(
            'reqAuthType' => $MOK_auth_resend_data_array->reqAuthType
            , 'encryptMOKToken' => $MOK_auth_resend_response_array->encryptMOKToken
            , 'publicKey' => $MOK_auth_resend_data_array->publicKey
            , 'resultCode' => $MOK_auth_resend_response_array->resultCode
            , 'resultMsg' => $MOK_auth_resend_response_array->resultMsg
        );

        return json_encode($MOK_confirm_data, JSON_UNESCAPED_SLASHES);
    }

    /* 본인확인-API 인증요청 정보 */
    function MOKAuthRequestToJsonString(
        $mobileOK
        , $public_key
        , $encrypt_MOK_token
        , $site_url
        , $provider_id
        , $req_auth_type
        , $usage_code
        , $service_type
        , $user_name
        , $user_phone_num
        , $ret_transfer_type
        , $ars_code
        , $user_birthday
        , $user_gender
        , $user_nation
        , $send_msg
        , $reply_number
        , $extension) {

        $MOK_auth_info_array = array(
            "providerId" => $provider_id
            , "reqAuthType" => $req_auth_type
            , "usageCode" => $usage_code
            , "serviceType" => $service_type
            , "userName" => $user_name
            , "userPhone" => $user_phone_num
            , "retTransferType" => $ret_transfer_type
        );
        if ('telcoAuth-ARSAuth' == $_POST['serviceType']) {
            $MOK_auth_info_array["arsCode"] = $ars_code;
            $MOK_auth_info_array["userBirthday"] = $user_birthday;
            $MOK_auth_info_array["userGender"] = $user_gender;
            $MOK_auth_info_array["userNation"] = $user_nation;
            $MOK_auth_info_array["extension"] = $extension;

            if ("" != $reply_number) {
                $MOK_auth_info_array["replyNumber"] = $reply_number;
            }
        } else if (strpos($_POST['serviceType'], 'telcoAuth') !== false
                && 'SMS' == $_POST['reqAuthType']
                || 'LMS' == $_POST['reqAuthType']) {
            $MOK_auth_info_array["userBirthday"] = $user_birthday;
            $MOK_auth_info_array["userGender"] = $user_gender;
            $MOK_auth_info_array["userNation"] = $user_nation;
            if ("" != $send_msg) {
                $MOK_auth_info_array["sendMsg"] = $send_msg;
            }
            if ("" != $reply_number) {
                $MOK_auth_info_array["replyNumber"] = $reply_number;
            }
        } else if ("SMSAuth" == $service_type) {
            if ("" != $send_msg) {
                $MOK_auth_info_array["sendMsg"] = $send_msg;
            }
            if ("" != $reply_number) {
                $MOK_auth_info_array["replyNumber"] = $reply_number;
            }
        } 

        $enc_MOK_auth_info = $mobileOK->rsa_public_encrypt($public_key, json_encode($MOK_auth_info_array, JSON_UNESCAPED_SLASHES));

        $auth_request_array = array(
            "siteUrl" => $site_url
            , "encryptMOKToken" => $encrypt_MOK_token
            , "encryptMOKAuthInfo" => $enc_MOK_auth_info
        );

        return json_encode($auth_request_array, JSON_UNESCAPED_SLASHES);
    }

    /* 본인확인 서버 통신 예제 함수 */
    function sendPost($data, $url) {
        $curl = curl_init();                                                              // curl 초기화
        curl_setopt($curl, CURLOPT_URL, $url);                                            // 데이터를 전송 할 URL
        curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);                                 // 요청결과를 문자열로 반환
        curl_setopt($curl, CURLOPT_HTTPHEADER, array('Content-Type: application/json'));  // 전송 ContentType을 Json형식으로 설정
        curl_setopt($curl, CURLOPT_SSL_VERIFYPEER, false);                                // 원격 서버의 인증서가 유효한지 검사 여부
        curl_setopt($curl, CURLOPT_POSTFIELDS, $data);                                    // POST DATA
        curl_setopt($curl, CURLOPT_POST, true);                                           // POST 전송 여부
        $response = curl_exec($curl);                                                     // 전송
        curl_close($curl);                                                                // 연결해제

        return $response;
    }
?>


<!DOCTYPE html>
<html>
<head>
    <title>mok_api_auth_request</title>
    <script>
        const MOKAuthRequestJson = decodeURIComponent('<?php echo $MOK_AUTH_REQUEST_RESULT ?>');
        const MOKAuthRequestJsonObject = JSON.parse(MOKAuthRequestJson);

        document.addEventListener("DOMContentLoaded", function () {
            if (MOKAuthRequestJsonObject.resultCode != '2000') {
                /* 오류발생시 */
                window.alert(MOKAuthRequestJsonObject.resultCode + ', ' + MOKAuthRequestJsonObject.resultMsg);
            } else {
                /* 정장작동시 */
                document.getElementById("MOKConfirmData").value = MOKAuthRequestJson;
                document.getElementById("MOKAuthResendData").value = MOKAuthRequestJson;
                document.getElementById("MOKCallData").value = MOKAuthRequestJson;
                document.getElementById("arsOtpNumber").innerText = MOKAuthRequestJsonObject.arsOtpNumber;
            }
        });
    </script>
</head>
<body>
    <form action='<?php echo $MOK_API_RESULT_PHP ?>' method="post">
        <h1> Auth Request Page </h1>
        <input type="hidden" id="MOKConfirmData" name="MOKConfirmData" value='' />

        <h3>인증완료 후 완료버튼을 눌러주세요.</h2>
        <input type="submit" value="완료" style="width:160px; height:30px; margin-right:5px;" />

        <a href='<?php echo $MOK_API_GET_TOKEN_PHP ?>'> 
            <input type="button" style="width:160px; height:30px; margin-left:5px; margin-bottom:15px;" value='취소' />
        </a>
    <!-- 인증방식이 SMS일 경우에만 사용 START -->
    <h3>(인증번호를 수신하는 경우) 인증번호를 입력 후 완료버튼을 눌러주세요.</h3>
    인증번호 : <input type="text" id="authNumber" name="authNumber" value='' style="width: 245px; height: 20px; margin-bottom: 15px;"/> (인증방식 SMS, LMS일 경우 필수) <br>
    <input type="submit" value="완료" style="width:160px; height:30px; margin-right:5px;" />

        <a href='<?php echo $MOK_API_GET_TOKEN_PHP ?>'> 
            <input type="button" style="width:160px; height:30px; margin-left:5px; margin-bottom:15px;" value='취소' />
        </a>
    <!-- 인증방식이 SMS일 경우에만 사용 END -->
    </form>
    <form action="<?php echo $MOK_API_REQUEST_PHP ?>" method="post">
        <input type="hidden" id="MOKAuthResendData" name="MOKAuthResendData" value='' />
        <button id="resend" name="resend" style="width:335px; height:30px;" >재요청</button>
    </form>
    <!-- 인증방식이 ARS 점유인증일 경우에만 사용 END -->
    <form action="<?php echo $MOK_API_CALL_PHP ?>" method="post">
        <input type="hidden" id="MOKCallData" name="MOKCallData" value='' />     
        <h3>ARS 전화요청 인증번호 (인증번호를 ARS전화요청시 입력하여 주십시오.)</h3>
        <div>인증번호 : <span id="arsOtpNumber"></span></div>
        <input type="submit" value="전화걸기" style="width:160px; height:30px; margin-right:5px;" />
        <a href="<?php $MOK_API_GET_TOKEN_PHP ?>"> 
            <input type="button" style="width:160px; height:30px; margin-left:5px; margin-bottom:15px;" value='취소' />
        </a>
    </form>
</body>
</html>
    views/mok_api_request.ejs
     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
    <%#  // server_api.js 에 eziok_api_request 처리 기능 참조 %><%#  // server_api.js 에 eziok_api_request 처리 기능 참조 %>
<!DOCTYPE html>
<html>
<head>
<title>mok_api_auth_request</title>
<script>
    const MOKAuthRequestJson = ('<%- MOKConfirmData %>');
    const MOKAuthRequestJsonObject = JSON.parse(MOKAuthRequestJson);

    document.addEventListener("DOMContentLoaded", function () {
    if (MOKAuthRequestJsonObject.resultCode != '2000') {
    /* 오류발생시 */
    window.alert(MOKAuthRequestJsonObject.resultCode + ', ' + MOKAuthRequestJsonObject.resultMsg);
} else {
    /* 정장작동시 */
    document.getElementById("MOKConfirmData").value = encodeURIComponent(MOKAuthRequestJson);
    document.getElementById("MOKAuthResendData").value = encodeURIComponent(MOKAuthRequestJson);
    document.getElementById("MOKCallData").value = encodeURIComponent(MOKAuthRequestJson);
    document.getElementById("arsOtpNumber").innerText = MOKAuthRequestJsonObject.arsOtpNumber;
}
});
</script>
</head>
<body>
    <form action='<%- reqUrl.MOKConfirmUri %>' method="post" onsubmit='return checkAuthNumber();'>
        <h1> Auth Request Page </h1>
        <input type="hidden" id="MOKConfirmData" name="MOKConfirmData" value='' />

        <h3>(인증방식 PASS 또는 ARS 일 경우) 인증완료 후 완료버튼을 눌러주세요. </h2>
        <input type="submit" value="완료" style="width:160px; height:30px; margin-right:5px;" />

        <a href='<%- reqUrl.MOKGetTokenUri %>'>
            <input type="button" style="width:160px; height:30px; margin-left:5px; margin-bottom:15px;" value='취소' />
        </a>
        <!-- 인증방식이 SMS일 경우에만 사용 START -->
        <h3>(인증방식 SMS 일 경우) 수신 받은 인증번호를 입력 후 완료버튼을 눌러주세요.</h3>
        인증번호 : <input type="text" id="authNumber" name="authNumber" value='' style="width: 245px; height: 20px; margin-bottom: 15px;"/> (인증방식 SMS일 경우 필수) <br>
        <input type="submit" value="완료" style="width:160px; height:30px; margin-right:5px;" />
        <a href='<%- reqUrl.MOKGetTokenUri %>'>
            <input type="button" style="width:160px; height:30px; margin-left:5px; margin-bottom:15px;" value='취소' />
        </a>
        <!-- 인증방식이 SMS일 경우에만 사용 END -->
    </form>
    <form action="<%- reqUrl.MOKResendUri %>" method="post">
        <input type="hidden" id="MOKAuthResendData" name="MOKAuthResendData" value='' />
        <button id="resend" name="resend" style="width:335px; height:30px;" >재요청</button>
    </form>
    <!-- 인증방식이 ARS 점유인증일 경우에만 사용 END -->
    <form action='<%- reqUrl.MOKCallUri %>' method="post">
        <input type="hidden" id="MOKCallData" name="MOKCallData" value='' />
        <h3>ARS 전화요청 인증번호 (인증번호를 ARS전화요청시 입력하여 주십시오.)</h3>
        <div>인증번호 : <span id="arsOtpNumber"></span></div>
        <input type="submit" value="전화걸기" style="width:160px; height:30px; margin-right:5px;" />
        <a href='<%- reqUrl.MOKGetTokenUri %>'>
            <input type="button" style="width:160px; height:30px; margin-left:5px; margin-bottom:15px;" value='취소' />
        </a>
    </form>
</body>
</html>
    mok_api_request.aspx
     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
    <%@ Page Language="C#" AutoEventWireup="true" CodeBehind="mok_api_request.aspx.cs" Inherits="mok_api_request"%>
<%@ Import Namespace="System" %>
<!DOCTYPE html>
<html>
<head>
    <title>mok_api_auth_request</title>
    <script>
        const MOKAuthRequestJson = decodeURIComponent('<%= resultData %>');

        const MOKAuthRequestJsonObject = JSON.parse(MOKAuthRequestJson);


        document.addEventListener("DOMContentLoaded", function () {
            if (MOKAuthRequestJsonObject.resultCode !== '2000') {
                /* 오류발생시 */
                window.alert(MOKAuthRequestJsonObject.resultCode + ', ' + MOKAuthRequestJsonObject.resultMsg);
                window.history.back();
            } else {
                /* 정상작동시 */
                document.getElementById("MOKConfirmData").value = encodeURIComponent(MOKAuthRequestJson);
                document.getElementById("MOKAuthResendData").value = encodeURIComponent(MOKAuthRequestJson);
                document.getElementById("MOKCallData").value = encodeURIComponent(MOKAuthRequestJson);
                document.getElementById("arsOtpNumber").innerText = MOKAuthRequestJsonObject.arsOtpNumber;
            }
        });
    </script>
</head>
<body>
<input type="hidden" id="MOKAuthRequestData" runat="server" ClientIDMode="Static" />
    <form action='<%= MOK_RESULT_ASPX %>' method="post">
        <h1> Auth Request Page </h1>
        <input type="hidden" id="MOKConfirmData" name="MOKConfirmData" value='' />

        <h3>인증완료 후 완료버튼을 눌러주세요.</h2>
        <input type="submit" value="완료" style="width:160px; height:30px; margin-right:5px;" />

        <a href='<%= MOK_GET_TOKEN_ASPX %>'> 
            <input type="button" style="width:160px; height:30px; margin-left:5px; margin-bottom:15px;" value='취소' />
        </a>
    <!-- 인증방식이 SMS일 경우에만 사용 START -->
    <h3>(인증번호를 수신하는 경우) 인증번호를 입력 후 완료버튼을 눌러주세요.</h3>
    인증번호 : <input type="text" id="authNumber" name="authNumber" value='' style="width: 245px; height: 20px; margin-bottom: 15px;"/> (인증방식 SMS, LMS일 경우 필수) <br>
    <input type="submit" value="완료" style="width:160px; height:30px; margin-right:5px;" />

        <a href='<%= MOK_GET_TOKEN_ASPX %>'> 
            <input type="button" style="width:160px; height:30px; margin-left:5px; margin-bottom:15px;" value='취소' />
        </a>
    <!-- 인증방식이 SMS일 경우에만 사용 END -->
    </form>
    <form action="<%= MOK_REQUEST_ASPX %>" method="post">
        <input type="hidden" id="MOKAuthResendData" name="MOKAuthResendData" value='' />
        <button id="resend" name="resend" style="width:335px; height:30px;" >재요청</button>
    </form>
    <!-- 인증방식이 ARS 점유인증일 경우에만 사용 END -->
    <form action='<%= MOK_CALL_ASPX %>' method="post">
        <input type="hidden" id="MOKCallData" name="MOKCallData" value='' />     
        <h3>ARS 전화요청 인증번호 (인증번호를 ARS전화요청시 입력하여 주십시오.)</h3>
        <div>인증번호 : <span id="arsOtpNumber"></span></div>
        <input type="submit" value="전화걸기" style="width:160px; height:30px; margin-right:5px;" />
        <a href='<%= MOK_GET_TOKEN_ASPX %>'> 
            <input type="button" style="width:160px; height:30px; margin-left:5px; margin-bottom:15px;" value='취소' />
        </a>
    </form>
</body>
</html>
    mok_api_request.aspx.cs
      1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
    using System;
using System.Collections.Generic;
using System.Web;
using System.Web.Script.Services;
using System.Web.Services;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Threading.Tasks;
using System.Net.Http;
using System.Text;
using System.Web.UI.HtmlControls;
using System.Security.Authentication;

using System.IO;

using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using mokcrypto;
using System.Net;

public partial class mok_api_request : System.Web.UI.Page
{
/* 1. 본인확인 인증결과 MOKGetToken API 요청 URL 설정 */
//private string MOK_REQUEST_URL = "https://cert-dir.mobile-ok.com/agent/v1/auth/request";   // 운영
protected static string MOK_REQUEST_URL = "https://scert-dir.mobile-ok.com/agent/v1/auth/request";  // 개발
//protected static string MOK_RESEND_URL = "https://cert-dir.mobile-ok.com/agent/v1/auth/resend";        //운영
protected static string MOK_RESEND_URL = "https://scert-dir.mobile-ok.com/agent/v1/auth/resend";        // 개발

    // 완료 버튼 클릭시 이동 aspx (mobileOK-Result aspx)
    protected static string MOK_RESULT_ASPX = "./mok_api_result.aspx";
    // 취소 버튼 클릭시 이동 aspx (mobileOK-GetToken aspx)
    protected static string MOK_GET_TOKEN_ASPX = "./mok_api_gettoken.aspx";
    // 재전송 버튼 클릭시 이동 aspx (mobileOK-Request aspx)
    protected static string MOK_REQUEST_ASPX = "./mok_api_request.aspx";
    // 전화걸기 클릭시 이동 aspx (mobileOK-call aspx) - ARS
    protected static string MOK_CALL_ASPX = "./mok_ars_call.aspx";

    MobileOkKeyManager mobileOK = new MobileOkKeyManager();

    protected string resultData = "";
    protected string retryData = "";

    protected void Page_Load(object sender, EventArgs e)
    {
        /* 2. 본인확인 서비스 API 초기화 */
        MobileOkKeyManager mobileOK = new MobileOkKeyManager();
        try
        {
            /* 본인확인 키파일은 반드시 서버의 안전한 로컬경로에 별도 저장. 웹URL 경로에 파일이 있을경우 키파일이 외부에 노출될 수 있음 주의 */
            mobileOK.keyInit("/본인확인-API 키정보파일 Path/mok_keyInfo.dat", "키파일 패스워드");
            mobileOK.setSiteUrl("본인확인-API 등록 사이트 URL");
        }
        catch (MobileOKException ex)
        {
            resultData = SetErrorMsg(ex.Message);
            return;
        }
        var request = new HttpRequestMessage();

        string normalFlag = HttpContext.Current.Request.Form["normalFlag"];
        if (normalFlag == "")
        {
            resultData = SetErrorMsg("잘못된 접근입니다.");
            return;
        }
        string resendData = HttpContext.Current.Request.Form["MOKAuthResendData"];
        retryData = HttpContext.Current.Request.Form["MOKConfirmRetryData"];

        if (normalFlag == "Y")
        {
            resultData = mobileOK_api_auth_request(mobileOK, request);
        }
        else if (!string.IsNullOrEmpty(resendData))
        {
            /* 재전송 요청 (Auth Resend) */
            try
            {
                resendData = Uri.UnescapeDataString(resendData);
                resultData = mok_api_auth_resend(resendData);
            }
            catch (Exception ex)
            {
                resultData = SetErrorMsg("URLDecoding에 실패했습니다.");
                return;
            }

            resultData = mok_api_auth_resend(resendData);
        }
        else if (!string.IsNullOrEmpty(retryData))
        {
            /* 검증 재시도 (Confirm Retry) */
            try
            {
                retryData = Uri.UnescapeDataString(retryData);

                JObject retryDataJson = JObject.Parse(retryData);
                retryDataJson["resultCode"] = "2000";  // 재시도 요청에 성공했을 경우

                resultData = Uri.EscapeDataString(retryDataJson.ToString());
            }
            catch (Exception ex)
            {
                resultData = SetErrorMsg("URLEncoding에 실패했습니다.");
                return;
            }
        }
        else
        {
            resultData = SetErrorMsg("비정상적인 접근입니다.");
        }
    }


    /* 본인확인-API 인증요청 예제 함수 */
    public string mobileOK_api_auth_request(MobileOkKeyManager mobileOK, HttpRequestMessage request)
    {
        string MOKAuthRequestData = HttpContext.Current.Request.Form["MOKAuthRequestData"];
        dynamic MOKAuthRequestJson = JsonConvert.DeserializeObject(MOKAuthRequestData);

        /* 3. 본인확인 인증요청 입력정보 설정 (아래 MOKAuthInfoToJson() 참조) */
        string MOKAuthRequestJsonString = "";
        if ("PASS".Equals(HttpContext.Current.Request.Form["reqAuthType"]))
        {
            MOKAuthRequestJsonString = MOKAuthRequestToJsonString(
            mobileOK,
            MOKAuthRequestJson["publicKey"].ToString(),             // MOK_API_Gettoken 응답으로 받은 publicKey 
            MOKAuthRequestJson["encryptMOKToken"].ToString(),       // MOK_API_Gettoken 응답으로 받은 encryptMOKToken 
            mobileOK.GetSiteUrl(),                               // 본인확인-API 등록 사이트 URL 
            HttpContext.Current.Request.Form["providerid"],      // 인증 사업자 구분코드 
            HttpContext.Current.Request.Form["reqAuthType"],     // 본인확인 인증 처리 Type 코드 
            HttpContext.Current.Request.Form["usageCode"],       // 서비스 이용 코드 
            HttpContext.Current.Request.Form["serviceType"],     // 이용상품 코드 
            HttpContext.Current.Request.Form["userName"],        // 사용자 이름 
            HttpContext.Current.Request.Form["userPhoneNum"],    // 사용자 전화번호 
            HttpContext.Current.Request.Form["retTransferType"], // 요청 대상의 결과 전송 타입 
            "",                                                  // 운영자와 협의 된 ARS 코드 
            "",                                                  // 사용자 생년월일 
            "",                                                  // 사용자 성별 
            "",                                                  // 사용자 내외국인 정보 
            "",                                                  // SMS 발송내용 또는 LMS 발송내용 
            "",                                                   // SMS 또는 ARS 전송 시 사용할 송신번호 
            null                                                 // 이용기관별 추가정보 전달처리시 이용 JSON Object
        );
        }
        else if ("telcoAuth-ARSAuth".Equals(HttpContext.Current.Request.Form["serviceType"]))
        {
            JObject extension = new JObject();
            extension["arsRequestMsg"] = HttpContext.Current.Request.Form["arsRequestMsg"];

            MOKAuthRequestJsonString = MOKAuthRequestToJsonString(
                mobileOK,
                MOKAuthRequestJson["publicKey"].ToString(),             // MOK_API_Gettoken 응답으로 받은 publicKey 
                MOKAuthRequestJson["encryptMOKToken"].ToString(),       // MOK_API_Gettoken 응답으로 받은 encryptMOKToken 
                mobileOK.GetSiteUrl(),                                  // 본인확인-API 등록 사이트 URL 
                HttpContext.Current.Request.Form["providerid"],         // 인증 사업자 구분코드 
                HttpContext.Current.Request.Form["reqAuthType"],        // 본인확인 인증 처리 Type 코드 
                HttpContext.Current.Request.Form["usageCode"],          // 서비스 이용 코드 
                HttpContext.Current.Request.Form["serviceType"],        // 이용상품 코드 
                HttpContext.Current.Request.Form["userName"],           // 사용자 이름 
                HttpContext.Current.Request.Form["userPhoneNum"],       // 사용자 전화번호 
                HttpContext.Current.Request.Form["retTransferType"],    // 요청 대상의 결과 전송 타입 
                HttpContext.Current.Request.Form["arsCode"],            // 운영자와 협의 된 ARS 코드 
                HttpContext.Current.Request.Form["userBirthday"],       // 사용자 생년월일 
                HttpContext.Current.Request.Form["userGender"],         // 사용자 성별 
                HttpContext.Current.Request.Form["userNation"],         // 사용자 내외국인 정보 
                HttpContext.Current.Request.Form["sendMsg"],            // SMS 발송내용 또는 LMS 발송내용 
                HttpContext.Current.Request.Form["replyNumber"],         // SMS 또는 ARS 전송 시 사용할 송신번호 
                extension                                               // 이용기관별 추가정보 전달처리시 이용 JSON Object
            );
        }
        else if (HttpContext.Current.Request.Form["serviceType"].Contains("telcoAuth")
    && ("SMS".Equals(HttpContext.Current.Request.Form["reqAuthType"]) || "LMS".Equals(HttpContext.Current.Request.Form["reqAuthType"])))
        {
            MOKAuthRequestJsonString = MOKAuthRequestToJsonString(
                mobileOK,
                MOKAuthRequestJson["publicKey"].ToString(),          // MOK_API_Gettoken 응답으로 받은 publicKey 
                MOKAuthRequestJson["encryptMOKToken"].ToString(),    // MOK_API_Gettoken 응답으로 받은 encryptMOKToken 
                mobileOK.GetSiteUrl(),                               // 본인확인-API 등록 사이트 URL 
                HttpContext.Current.Request.Form["providerid"],      // 인증 사업자 구분코드 
                HttpContext.Current.Request.Form["reqAuthType"],     // 본인확인 인증 처리 Type 코드 
                HttpContext.Current.Request.Form["usageCode"],       // 서비스 이용 코드 
                HttpContext.Current.Request.Form["serviceType"],     // 이용상품 코드 
                HttpContext.Current.Request.Form["userName"],        // 사용자 이름 
                HttpContext.Current.Request.Form["userPhoneNum"],    // 사용자 전화번호 
                HttpContext.Current.Request.Form["retTransferType"], // 요청 대상의 결과 전송 타입 
                "",                                                  // 운영자와 협의 된 ARS 코드
                HttpContext.Current.Request.Form["userBirthday"],    // 사용자 생년월일 
                HttpContext.Current.Request.Form["userGender"],      // 사용자 성별 
                HttpContext.Current.Request.Form["userNation"],      // 사용자 내외국인 정보 
                HttpContext.Current.Request.Form["sendMsg"],         // SMS 발송내용 또는 LMS 발송내용 
                HttpContext.Current.Request.Form["replyNumber"],      // SMS 또는 ARS 전송 시 사용할 송신번호 
                null                                                 // 이용기관별 추가정보 전달처리시 이용 JSON Object
            );
        }
        else if ("SMSAuth" == HttpContext.Current.Request.Form["serviceType"])
        {
            MOKAuthRequestJsonString = MOKAuthRequestToJsonString(
                mobileOK,
                MOKAuthRequestJson["publicKey"].ToString(),          // MOK_API_Gettoken 응답으로 받은 publicKey 
                MOKAuthRequestJson["encryptMOKToken"].ToString(),    // MOK_API_Gettoken 응답으로 받은 encryptMOKToken 
                mobileOK.GetSiteUrl(),                               // 본인확인-API 등록 사이트 URL 
                HttpContext.Current.Request.Form["providerid"],      // 인증 사업자 구분코드 
                HttpContext.Current.Request.Form["reqAuthType"],     // 본인확인 인증 처리 Type 코드 
                HttpContext.Current.Request.Form["usageCode"],       // 서비스 이용 코드
                HttpContext.Current.Request.Form["serviceType"],     // 이용상품 코드 
                HttpContext.Current.Request.Form["userName"],        // 사용자 이름 
                HttpContext.Current.Request.Form["userPhoneNum"],    // 사용자 전화번호 
                HttpContext.Current.Request.Form["retTransferType"], // 요청 대상의 결과 전송 타입 
                "",                                                  // 운영자와 협의 된 ARS 코드 
                "",                                                  // 사용자 생년월일 
                "",                                                  // 사용자 성별 
                "",                                                  // 사용자 내외국인 정보
                HttpContext.Current.Request.Form["sendMsg"],         // SMS 발송내용 또는 LMS 발송내용 
                HttpContext.Current.Request.Form["replyNumber"],      // SMS 또는 ARS 전송 시 사용할 송신번호
                null                                                 // 이용기관별 추가정보 전달처리시 이용 JSON Object
            );
        }
        else
        {
            return SetErrorMsg("인증 사업자 구분코드와 본인확인 인증 처리 Type 코드는 대문자로 입력");
        }
        /* 4. 본인확인 인증요청 */
        string MOKAuthResponseJsonString = SendPost(MOK_REQUEST_URL, MOKAuthRequestJsonString);

        dynamic MOKAuthResponseJson = JObject.Parse(MOKAuthResponseJsonString);
        string resultCode = MOKAuthResponseJson["resultCode"].ToString();

        if ("2000" != resultCode)
        {
            return JsonConvert.SerializeObject(MOKAuthResponseJson);
        }

        /* 5. 본인확인 검증요청 API에서 이용할 데이터 설정 */
        dynamic MOKConfirmData = new JObject();
        if ("telcoAuth-ARSAuth".Equals(HttpContext.Current.Request.Form["serviceType"]))
        {
            MOKConfirmData["encryptMOKToken"] = MOKAuthResponseJson["encryptMOKToken"];
            MOKConfirmData["resultCode"] = MOKAuthResponseJson["resultCode"];
            MOKConfirmData["resultMsg"] = MOKAuthResponseJson["resultMsg"];
            MOKConfirmData["publicKey"] = MOKAuthRequestJson["publicKey"];
            MOKConfirmData["arsOtpNumber"] = MOKAuthResponseJson["arsOtpNumber"];
        } else
        {
            MOKConfirmData["encryptMOKToken"] = MOKAuthResponseJson["encryptMOKToken"];
            MOKConfirmData["resultCode"] = MOKAuthResponseJson["resultCode"];
            MOKConfirmData["resultMsg"] = MOKAuthResponseJson["resultMsg"];
            MOKConfirmData["publicKey"] = MOKAuthRequestJson["publicKey"];
            MOKConfirmData["arsOtpNumber"] = "";
        }

        /* 5-1. 본인확인 검증요청 입력정보 URLEncoding */
        string MOKConfirmDataString;
        try
        {
            MOKConfirmDataString = HttpUtility.UrlEncode(MOKConfirmData.ToString());
            MOKConfirmDataString = MOKConfirmDataString.Replace("+", string.Empty);
        }
        catch (Exception e)
        {
            return SetErrorMsg("URLEncoding에 실패했습니다.");
        }
        return MOKConfirmDataString;
    }

    /* 본인확인-API 인증재요청 예제 함수 */
    [WebMethod]
    public string mok_api_auth_resend(string MOKAuthResendData)
    {
        dynamic MOKAuthResendDataJson = JObject.Parse(MOKAuthResendData);

        /* 1. 본인확인 재전송 요청 입력정보 설정 */
        dynamic MOKAuthResendRequest = new JObject();
        MOKAuthResendRequest["encryptMOKToken"] = MOKAuthResendDataJson.encryptMOKToken;

        /* 2. 본인확인 재전송 요청 */
        string MOKAuthResendResponse = SendPost(MOK_RESEND_URL, MOKAuthResendRequest.ToString());

        /* 3. 본인확인 재전송 결과 정보 */
        dynamic MOKAuthResendResponseJson = JObject.Parse(MOKAuthResendResponse);

        /* 4. 본인확인 재전송 실패시 */
        if ("2000" != MOKAuthResendResponseJson.GetValue("resultCode").ToString())
        {
            return JsonConvert.SerializeObject(MOKAuthResendResponseJson);
        }

        /* 5 본인확인 결과요청 입력 정보 설정 */
        dynamic MOKConfirmData = new JObject();
        MOKConfirmData["reqAuthType"] = MOKAuthResendDataJson.reqAuthType;
        MOKConfirmData["publicKey"] = MOKAuthResendDataJson.publicKey;
        MOKConfirmData["encryptMOKToken"] = MOKAuthResendDataJson.encryptMOKToken;
        MOKConfirmData["resultCode"] = MOKAuthResendDataJson.resultCode;
        MOKConfirmData["resultMsg"] = MOKAuthResendDataJson.resultMsg;

        /* 6 본인확인 결과요청 입력 정보 URLEncoding */
        string MOKConfirmDataString;
        try
        {
            MOKConfirmDataString = HttpUtility.UrlEncode(MOKConfirmData.ToString());
            MOKConfirmDataString = MOKConfirmDataString.Replace("+", string.Empty);
            return MOKConfirmDataString;
        }
        catch (Exception e)
        {
            return SetErrorMsg("URLEncoding에 실패했습니다.");
        }
    }

    /* 본인확인-API 인증요청 정보 */
    private string MOKAuthRequestToJsonString(
        MobileOkKeyManager mobileOK,
        string publicKey,
        string encryptMOKToken,
        string siteUrl,
        string providerId,
        string reqAuthType,
        string usageCode,
        string serviceType,
        string userName,
        string userPhoneNum,
        string retTransferType,
        string arsCode,
        string userBirthday,
        string userGender,
        string userNation,
        string sendMsg,
        string replyNumber,
        JObject extension)
    {
        JObject MOKAuthInfoJson = new JObject();
        MOKAuthInfoJson["providerId"] = providerId;
        MOKAuthInfoJson["reqAuthType"] = reqAuthType;
        MOKAuthInfoJson["usageCode"] = usageCode;
        MOKAuthInfoJson["serviceType"] = serviceType;
        MOKAuthInfoJson["userName"] = userName;
        MOKAuthInfoJson["userPhone"] = userPhoneNum;
        MOKAuthInfoJson["retTransferType"] = retTransferType;

        if ("telcoAuth-ARSAuth".Equals(serviceType))
        {
            MOKAuthInfoJson["arsCode"] = arsCode;
            MOKAuthInfoJson["userBirthday"] = userBirthday;
            MOKAuthInfoJson["userGender"] = userGender;
            MOKAuthInfoJson["userNation"] = userNation;
            MOKAuthInfoJson["replyNumber"] = replyNumber;
            MOKAuthInfoJson["extension"] = extension;
        }
        else if (serviceType.Contains("telcoAuth") && ("SMS".Equals(reqAuthType) || "LMS".Equals(reqAuthType)))
        {
            MOKAuthInfoJson["userBirthday"] = userBirthday;
            MOKAuthInfoJson["userGender"] = userGender;
            MOKAuthInfoJson["userNation"] = userNation;

            if (!string.IsNullOrEmpty(sendMsg))
            {
                MOKAuthInfoJson["sendMsg"] = sendMsg;
            }

            if (!string.IsNullOrEmpty(replyNumber))
            {
                MOKAuthInfoJson["replyNumber"] = replyNumber;
            }
        }
        else if ("ARSAuth".Equals(serviceType))
        {
            MOKAuthInfoJson["arsCode"] = arsCode;

            if (!string.IsNullOrEmpty(sendMsg))
            {
                MOKAuthInfoJson["sendMsg"] = sendMsg;
            }

            if (!string.IsNullOrEmpty(replyNumber))
            {
                MOKAuthInfoJson["replyNumber"] = replyNumber;
            }
        }
        else if ("SMSAuth".Equals(serviceType))
        {
            if (!string.IsNullOrEmpty(sendMsg))
            {
                MOKAuthInfoJson["sendMsg"] = sendMsg;
            }

            if (!string.IsNullOrEmpty(replyNumber))
            {
                MOKAuthInfoJson["replyNumber"] = replyNumber;
            }
        }

        string encMOKAuthInfo = mobileOK.RSAServerEncrypt(publicKey, MOKAuthInfoJson.ToString());

        JObject MOKAuthRequestJson = new JObject();
        MOKAuthRequestJson["siteUrl"] = siteUrl;
        MOKAuthRequestJson["encryptMOKToken"] = encryptMOKToken;
        MOKAuthRequestJson["encryptMOKAuthInfo"] = encMOKAuthInfo;

        return MOKAuthRequestJson.ToString();
    }

    /* 본인확인 서버 통신 예제 함수 */
    private string SendPost(string url, string json)
    {
        SecurityProtocolType originalProtocol = ServicePointManager.SecurityProtocol;
        try
        {
            ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12;
            HttpWebRequest request = (HttpWebRequest)WebRequest.Create(url);
            request.Method = "POST";
            request.ContentType = "application/json";

            byte[] data = Encoding.UTF8.GetBytes(json);
            request.ContentLength = data.Length;

            using (Stream stream = request.GetRequestStream())
            {
                stream.Write(data, 0, data.Length);
            }

            using (HttpWebResponse response = (HttpWebResponse)request.GetResponse())
            {
                if (response.StatusCode == HttpStatusCode.OK)
                {
                    using (StreamReader reader = new StreamReader(response.GetResponseStream(), Encoding.UTF8))
                    {
                        return reader.ReadToEnd();
                    }
                }
                else
                {
                    return null;
                }
            }
        }
        finally
        {
            // 기존 TLS 설정 복원
            ServicePointManager.SecurityProtocol = originalProtocol;
        }
    }

    //에러메시지 설정
    private string SetErrorMsg(string errorMsg)
    {
        JObject errorJson = new JObject();
        errorJson["resultMsg"] = errorMsg;
        string errJson = HttpUtility.UrlEncode(errorJson.ToString());
        errJson = errJson.Replace("+", " ");
        return errJson;
    }
}
    RequestController.cs
      1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
    using Microsoft.AspNetCore.Mvc;
using Newtonsoft.Json.Linq;
using Newtonsoft.Json;
using System.Web;
using mokcrypto;
using System.Threading.Tasks;
using System.Collections.Generic;
using System;
using System.Net.Http;
using System.IO;

namespace AspNetCoreAllInOne.Controllers
{
public class RequestController : Controller
{
/*1. 본인확인 인증결과 MOKAuth API 또는 MOKResend API 요청 URL*/
//private string MOK_REQUEST_URL = "https://cert-dir.mobile-ok.com/agent/v1/auth/request";   // 운영
private static string MOK_REQUEST_URL = "https://scert-dir.mobile-ok.com/agent/v1/auth/request";  // 개발
//protected static string MOK_RESEND_URL = "https://cert-dir.mobile-ok.com/agent/v1/auth/resend";        //운영
private static string MOK_RESEND_URL = "https://scert-dir.mobile-ok.com/agent/v1/auth/resend";        // 개발

        [HttpPost]
        public async Task<IActionResult> mok_api_request()
        {
            /*2. 본인확인 서비스 API 초기화 */
            MobileOkKeyManager mobileOK = new MobileOkKeyManager();
            try
            {
                /* 본인확인 키파일은 반드시 서버의 안전한 로컬경로에 별도 저장. 웹URL 경로에 파일이 있을경우 키파일이 외부에 노출될 수 있음 주의 */
                mobileOK.keyInit("/본인확인-API 키정보파일 Path/mok_keyInfo.dat", "키파일 패스워드");
                mobileOK.SetSiteUrl("본인확인-API 등록 사이트 URL");
            }
            catch (MobileOKException ex)
            {
                ViewData["message"] = ex.Message;
                return View();
            }


            string resultData = null;
            string resendData = null;
            string retryData = null;

            if (HttpContext.Request.Form["normalFlag"] == "Y") // 정상요청 여부 확인용
            {
                resultData = await mobileOK_api_auth_request(mobileOK);
            }
            else if (!string.IsNullOrEmpty(HttpContext.Request.Form["MOKAuthResendData"])) // 재전송 여부 확인용
            {
                try
                {
                    retryData = Uri.UnescapeDataString(HttpContext.Request.Form["MOKConfirmRetryData"]);

                    JObject retryDataJson = JObject.Parse(retryData);
                    retryDataJson["resultCode"] = "2000";  // 재시도 요청에 성공했을 경우

                    resultData = Uri.EscapeDataString(retryDataJson.ToString());
                }
                catch (Exception ex)
                {
                    resultData = "URLEncoding에 실패했습니다.";
                }
            }
            else if (!string.IsNullOrEmpty(HttpContext.Request.Form["MOKConfirmRetryData"])) //재시도 요청 데이터 여부 확인용
            {
                try
                {
                    retryData = Uri.UnescapeDataString(HttpContext.Request.Form["MOKConfirmRetryData"]);

                    JObject retryDataJson = JObject.Parse(retryData);
                    retryDataJson["resultCode"] = "2000";  // 재시도 요청에 성공했을 경우

                    resultData = Uri.EscapeDataString(retryDataJson.ToString());
                }
                catch (Exception ex)
                {
                    resultData = "URLEncoding에 실패했습니다.";
                }
            }
            else
            {
                resultData = "비정상적인 접근입니다.";
            }

            ViewData["message"] = resultData;

            return View();
        }

        /* 본인확인-API 인증요청 예제 함수 */
        public async Task<string> mobileOK_api_auth_request(MobileOkKeyManager mobileOK)
        {
            string MOKAuthRequestData = HttpContext.Request.Form["MOKAuthRequestData"];
            dynamic MOKAuthRequestJson = JsonConvert.DeserializeObject(MOKAuthRequestData);

            // 3. 본인확인 인증요청 입력정보 설정 (아래 MOKAuthInfoToJson() 참조) 
            string MOKAuthRequestJsonString = "";
            if ("PASS".Equals(HttpContext.Request.Form["reqAuthType"]))
            {
                MOKAuthRequestJsonString = MOKAuthRequestToJsonString(
                mobileOK,
                MOKAuthRequestJson["publicKey"].ToString(),             // MOK_API_Gettoken 응답으로 받은 publicKey 
                MOKAuthRequestJson["encryptMOKToken"].ToString(),       // MOK_API_Gettoken 응답으로 받은 encryptMOKToken 
                mobileOK.GetSiteUrl(),                               // 본인확인-API 등록 사이트 URL 
                HttpContext.Request.Form["providerid"],      // 인증 사업자 구분코드 
                HttpContext.Request.Form["reqAuthType"],     // 본인확인 인증 처리 Type 코드 
                HttpContext.Request.Form["usageCode"],       // 서비스 이용 코드 
                HttpContext.Request.Form["serviceType"],     // 이용상품 코드 
                HttpContext.Request.Form["userName"],        // 사용자 이름 
                HttpContext.Request.Form["userPhoneNum"],    // 사용자 전화번호 
                HttpContext.Request.Form["retTransferType"], // 요청 대상의 결과 전송 타입 
                "",                                                  // 운영자와 협의 된 ARS 코드 
                "",                                                  // 사용자 생년월일 
                "",                                                  // 사용자 성별 
                "",                                                  // 사용자 내외국인 정보 
                "",                                                  // SMS 발송내용 또는 LMS 발송내용 
                "",                                                   // SMS 또는 ARS 전송 시 사용할 송신번호 
                null                                                 // 이용기관별 추가정보 전달처리시 이용 JSON Object
            );
            }
            else if ("telcoAuth-ARSAuth".Equals(HttpContext.Request.Form["serviceType"]))
            {
                JObject extension = new JObject();
                extension["arsRequestMsg"] = HttpContext.Request.Form["arsRequestMsg"].ToString();

                MOKAuthRequestJsonString = MOKAuthRequestToJsonString(
                    mobileOK,
                    MOKAuthRequestJson["publicKey"].ToString(),             // MOK_API_Gettoken 응답으로 받은 publicKey 
                    MOKAuthRequestJson["encryptMOKToken"].ToString(),       // MOK_API_Gettoken 응답으로 받은 encryptMOKToken 
                    mobileOK.GetSiteUrl(),                                  // 본인확인-API 등록 사이트 URL 
                    HttpContext.Request.Form["providerid"],         // 인증 사업자 구분코드 
                    HttpContext.Request.Form["reqAuthType"],        // 본인확인 인증 처리 Type 코드 
                    HttpContext.Request.Form["usageCode"],          // 서비스 이용 코드 
                    HttpContext.Request.Form["serviceType"],        // 이용상품 코드 
                    HttpContext.Request.Form["userName"],           // 사용자 이름 
                    HttpContext.Request.Form["userPhoneNum"],       // 사용자 전화번호 
                    HttpContext.Request.Form["retTransferType"],    // 요청 대상의 결과 전송 타입 
                    HttpContext.Request.Form["arsCode"],            // 운영자와 협의 된 ARS 코드 
                    HttpContext.Request.Form["userBirthday"],       // 사용자 생년월일 
                    HttpContext.Request.Form["userGender"],         // 사용자 성별 
                    HttpContext.Request.Form["userNation"],         // 사용자 내외국인 정보 
                    HttpContext.Request.Form["sendMsg"],            // SMS 발송내용 또는 LMS 발송내용 
                    HttpContext.Request.Form["replyNumber"],         // SMS 또는 ARS 전송 시 사용할 송신번호
                    extension                                       // 이용기관별 추가정보 전달처리시 이용 JSON Object
                );
            }
            else if (HttpContext.Request.Form["serviceType"].ToString().Contains("telcoAuth")
            && ("SMS".Equals(HttpContext.Request.Form["reqAuthType"]) || "LMS".Equals(HttpContext.Request.Form["reqAuthType"])))
            {
                MOKAuthRequestJsonString = MOKAuthRequestToJsonString(
                    mobileOK,
                    MOKAuthRequestJson["publicKey"].ToString(),          // MOK_API_Gettoken 응답으로 받은 publicKey 
                    MOKAuthRequestJson["encryptMOKToken"].ToString(),    // MOK_API_Gettoken 응답으로 받은 encryptMOKToken 
                    mobileOK.GetSiteUrl(),                               // 본인확인-API 등록 사이트 URL 
                    HttpContext.Request.Form["providerid"],      // 인증 사업자 구분코드 
                    HttpContext.Request.Form["reqAuthType"],     // 본인확인 인증 처리 Type 코드 
                    HttpContext.Request.Form["usageCode"],       // 서비스 이용 코드 
                    HttpContext.Request.Form["serviceType"],     // 이용상품 코드 
                    HttpContext.Request.Form["userName"],        // 사용자 이름 
                    HttpContext.Request.Form["userPhoneNum"],    // 사용자 전화번호 
                    HttpContext.Request.Form["retTransferType"], // 요청 대상의 결과 전송 타입 
                    "",                                                  // 운영자와 협의 된 ARS 코드
                    HttpContext.Request.Form["userBirthday"],    // 사용자 생년월일 
                    HttpContext.Request.Form["userGender"],      // 사용자 성별 
                    HttpContext.Request.Form["userNation"],      // 사용자 내외국인 정보 
                    HttpContext.Request.Form["sendMsg"],         // SMS 발송내용 또는 LMS 발송내용 
                    HttpContext.Request.Form["replyNumber"],      // SMS 또는 ARS 전송 시 사용할 송신번호
                    null                                        // 이용기관별 추가정보 전달처리시 이용 JSON Object
                );
            }
            else if ("SMSAuth" == HttpContext.Request.Form["serviceType"])
            {
                MOKAuthRequestJsonString = MOKAuthRequestToJsonString(
                    mobileOK,
                    MOKAuthRequestJson["publicKey"].ToString(),          // MOK_API_Gettoken 응답으로 받은 publicKey 
                    MOKAuthRequestJson["encryptMOKToken"].ToString(),    // MOK_API_Gettoken 응답으로 받은 encryptMOKToken 
                    mobileOK.GetSiteUrl(),                               // 본인확인-API 등록 사이트 URL 
                    HttpContext.Request.Form["providerid"],      // 인증 사업자 구분코드 
                    HttpContext.Request.Form["reqAuthType"],     // 본인확인 인증 처리 Type 코드 
                    HttpContext.Request.Form["usageCode"],       // 서비스 이용 코드
                    HttpContext.Request.Form["serviceType"],     // 이용상품 코드 
                    HttpContext.Request.Form["userName"],        // 사용자 이름 
                    HttpContext.Request.Form["userPhoneNum"],    // 사용자 전화번호 
                    HttpContext.Request.Form["retTransferType"], // 요청 대상의 결과 전송 타입 
                    "",                                                  // 운영자와 협의 된 ARS 코드 
                    "",                                                  // 사용자 생년월일 
                    "",                                                  // 사용자 성별 
                    "",                                                  // 사용자 내외국인 정보
                    HttpContext.Request.Form["sendMsg"],         // SMS 발송내용 또는 LMS 발송내용 
                    HttpContext.Request.Form["replyNumber"],      // SMS 또는 ARS 전송 시 사용할 송신번호
                    null                                         // 이용기관별 추가정보 전달처리시 이용 JSON Object
                );
            }
            else
            {
                return "인증 사업자 구분코드와 본인확인 인증 처리 Type 코드는 대문자로 입력";
            }

            /* 4. 본인확인 인증요청 */
            string MOKAuthResponseJsonString = await SendPost(MOK_REQUEST_URL, MOKAuthRequestJsonString);

            dynamic MOKAuthResponseJson = JObject.Parse(MOKAuthResponseJsonString);
            string resultCode = MOKAuthResponseJson["resultCode"].ToString();

            if ("2000" != resultCode)
            {
                return JsonConvert.SerializeObject(MOKAuthResponseJson);
            }

            // 본인확인 검증요청 API에서 이용할 데이터 설정 
            /* 5. 본인확인 검증요청 API에서 이용할 데이터 설정 */
            dynamic MOKConfirmData = new JObject();
            if ("telcoAuth-ARSAuth".Equals(HttpContext.Request.Form["serviceType"]))
            {
                MOKConfirmData["encryptMOKToken"] = MOKAuthResponseJson["encryptMOKToken"];
                MOKConfirmData["resultCode"] = MOKAuthResponseJson["resultCode"];
                MOKConfirmData["resultMsg"] = MOKAuthResponseJson["resultMsg"];
                MOKConfirmData["publicKey"] = MOKAuthRequestJson["publicKey"];
                MOKConfirmData["arsOtpNumber"] = MOKAuthResponseJson["arsOtpNumber"];
            }
            else
            {
                MOKConfirmData["encryptMOKToken"] = MOKAuthResponseJson["encryptMOKToken"];
                MOKConfirmData["resultCode"] = MOKAuthResponseJson["resultCode"];
                MOKConfirmData["resultMsg"] = MOKAuthResponseJson["resultMsg"];
                MOKConfirmData["publicKey"] = MOKAuthRequestJson["publicKey"];
                MOKConfirmData["arsOtpNumber"] = "";
            }

            // 본인확인 검증요청 입력정보 URLEncoding 
            string MOKConfirmDataString;
            try
            {
                MOKConfirmDataString = HttpUtility.UrlEncode(MOKConfirmData.ToString());
                MOKConfirmDataString = MOKConfirmDataString.Replace("+", string.Empty);
            }
            catch (Exception e)
            {
                return "URLEncoding에 실패했습니다.";
            }
            return MOKConfirmDataString;
        }

        /* 본인확인-API 인증요청 정보 */
        private string MOKAuthRequestToJsonString(
        MobileOkKeyManager mobileOK,
        string publicKey,
        string encryptMOKToken,
        string siteUrl,
        string providerId,
        string reqAuthType,
        string usageCode,
        string serviceType,
        string userName,
        string userPhoneNum,
        string retTransferType,
        string arsCode,
        string userBirthday,
        string userGender,
        string userNation,
        string sendMsg,
        string replyNumber,
        JObject extension)
        {
            JObject MOKAuthInfoJson = new JObject();
            MOKAuthInfoJson["providerId"] = providerId;
            MOKAuthInfoJson["reqAuthType"] = reqAuthType;
            MOKAuthInfoJson["usageCode"] = usageCode;
            MOKAuthInfoJson["serviceType"] = serviceType;
            MOKAuthInfoJson["userName"] = userName;
            MOKAuthInfoJson["userPhone"] = userPhoneNum;
            MOKAuthInfoJson["retTransferType"] = retTransferType;

            if ("telcoAuth-ARSAuth".Equals(serviceType))
            {
                MOKAuthInfoJson["arsCode"] = arsCode;
                MOKAuthInfoJson["userBirthday"] = userBirthday;
                MOKAuthInfoJson["userGender"] = userGender;
                MOKAuthInfoJson["userNation"] = userNation;
                MOKAuthInfoJson["replyNumber"] = replyNumber;
                MOKAuthInfoJson["extension"] = extension;
            }
            else if (serviceType.Contains("telcoAuth") && ("SMS".Equals(reqAuthType) || "LMS".Equals(reqAuthType)))
            {
                MOKAuthInfoJson["userBirthday"] = userBirthday;
                MOKAuthInfoJson["userGender"] = userGender;
                MOKAuthInfoJson["userNation"] = userNation;

                if (!string.IsNullOrEmpty(sendMsg))
                {
                    MOKAuthInfoJson["sendMsg"] = sendMsg;
                }

                if (!string.IsNullOrEmpty(replyNumber))
                {
                    MOKAuthInfoJson["replyNumber"] = replyNumber;
                }
            }
            else if ("ARSAuth".Equals(serviceType))
            {
                MOKAuthInfoJson["arsCode"] = arsCode;

                if (!string.IsNullOrEmpty(sendMsg))
                {
                    MOKAuthInfoJson["sendMsg"] = sendMsg;
                }

                if (!string.IsNullOrEmpty(replyNumber))
                {
                    MOKAuthInfoJson["replyNumber"] = replyNumber;
                }
            }
            else if ("SMSAuth".Equals(serviceType))
            {
                if (!string.IsNullOrEmpty(sendMsg))
                {
                    MOKAuthInfoJson["sendMsg"] = sendMsg;
                }

                if (!string.IsNullOrEmpty(replyNumber))
                {
                    MOKAuthInfoJson["replyNumber"] = replyNumber;
                }
            }

            string encMOKAuthInfo = mobileOK.RSAServerEncrypt(publicKey, MOKAuthInfoJson.ToString());

            JObject MOKAuthRequestJson = new JObject();
            MOKAuthRequestJson["siteUrl"] = siteUrl;
            MOKAuthRequestJson["encryptMOKToken"] = encryptMOKToken;
            MOKAuthRequestJson["encryptMOKAuthInfo"] = encMOKAuthInfo;

            return MOKAuthRequestJson.ToString();
        }

        /* 본인확인 서버 통신 예제 함수 */
        private async Task<string> SendPost(string url, string json)
        {
            try
            {
                HttpClient client = new HttpClient();

                var content = new StringContent(json, System.Text.Encoding.UTF8, "application/json");

                var response = await client.PostAsync(url, content);

                if (response.IsSuccessStatusCode)
                {
                    string responseString = await response.Content.ReadAsStringAsync();
                    return responseString;
                }
                else
                {
                    return null;
                }
            }
            catch (HttpRequestException ex)
            {
                Console.WriteLine("HttpRequestException: " + ex.Message);
                return null;
            }
            catch (TaskCanceledException ex)
            {
                Console.WriteLine("TaskCanceledException: " + ex.Message);
                return null;
            }
            catch (IOException ex)
            {
                Console.WriteLine("IOException: " + ex.Message);
                return null;
            }
        }

        /* 본인확인-API 인증재요청 예제 함수 */
        public async Task<string> mok_api_auth_resend(string MOKAuthResendData)
        {
            dynamic MOKAuthResendDataJson = JObject.Parse(MOKAuthResendData);

            // 1. 본인확인 재전송 요청 입력정보 설정 
            dynamic MOKAuthResendRequest = new JObject();
            MOKAuthResendRequest["encryptMOKToken"] = MOKAuthResendDataJson.encryptMOKToken;

            // 2. 본인확인 재전송 요청 
            string MOKAuthResendResponse = await SendPost(MOK_RESEND_URL, MOKAuthResendRequest.ToString());

            // 3. 본인확인 재전송 결과 정보 
            dynamic MOKAuthResendResponseJson = JObject.Parse(MOKAuthResendResponse);

            // 4. 본인확인 재전송 실패시 
            if ("2000" != MOKAuthResendResponseJson.GetValue("resultCode").ToString())
            {
                return JsonConvert.SerializeObject(MOKAuthResendResponseJson);
            }

            // 5 본인확인 결과요청 입력 정보 설정 
            dynamic MOKConfirmData = new JObject();
            MOKConfirmData["reqAuthType"] = MOKAuthResendDataJson.reqAuthType;
            MOKConfirmData["publicKey"] = MOKAuthResendDataJson.publicKey;
            MOKConfirmData["encryptMOKToken"] = MOKAuthResendDataJson.encryptMOKToken;
            MOKConfirmData["resultCode"] = MOKAuthResendDataJson.resultCode;
            MOKConfirmData["resultMsg"] = MOKAuthResendDataJson.resultMsg;

            string MOKConfirmDataString;
            try
            {
                MOKConfirmDataString = HttpUtility.UrlEncode(MOKConfirmData.ToString());
                MOKConfirmDataString = MOKConfirmDataString.Replace("+", string.Empty);
            }
            catch (Exception e)
            {
                return "URLEncoding에 실패했습니다."; // Replace setErrorMsg with your own error handling logic
            }

            // 6 본인확인 결과요청 입력 정보 URLEncoding 
            try
            {
                return MOKConfirmDataString;
            }
            catch
            {
                return "URLEncoding에 실패했습니다.";
            }
        }
    }
}
    mok_api_request.cshtml
     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
    @{
    // 완료 버튼 클릭시 이동
    string MOK_RESULT_CSHTML = "./mok_api_result";
    // 취소 버튼 클릭시 이동
    string MOK_GET_TOKEN_CSHTML = "./mok_api_gettoken";
    // 재전송 버튼 클릭시 이동
    string MOK_REQUEST_CSHTML = "./mok_api_request";
    // 전화걸기 버튼 클릭시 이동
    string MOK_CALL_CSHTML = "./mok_ars_call";
}

<!DOCTYPE html>
<html>
<head>
    <title>mok_api_auth_request</title>
    <script>
        const MOKAuthRequestJson = decodeURIComponent('@Html.Raw(@ViewData["message"])');
        document.addEventListener("DOMContentLoaded", function () {
            var MOKAuthRequestJsonObject;

            try {
                MOKAuthRequestJsonObject = JSON.parse(MOKAuthRequestJson);
                if (MOKAuthRequestJsonObject.resultCode !== '2000') {
                    /* 오류발생시 */
                    window.alert(MOKAuthRequestJsonObject.resultCode + ', ' + MOKAuthRequestJsonObject.resultMsg);
                    window.history.back();
                } else {
                    /* 정상작동시 */
                    document.getElementById("MOKConfirmData").value = encodeURIComponent(MOKAuthRequestJson);
                    document.getElementById("MOKAuthResendData").value = encodeURIComponent(MOKAuthRequestJson);
                    document.getElementById("MOKCallData").value = encodeURIComponent(MOKAuthRequestJson);
                    document.getElementById("arsOtpNumber").innerText = MOKAuthRequestJsonObject.arsOtpNumber;
                }
            } catch (e) {
                window.alert(MOKAuthRequestJson);
            }
        });
    </script>
</head>
<body>
    <form action=@MOK_RESULT_CSHTML method="post">
        <h1> Auth Request Page </h1>
        <input type="hidden" id="MOKConfirmData" name="MOKConfirmData" value='' />

        <h3>인증완료 후 완료버튼을 눌러주세요.</h3>
        <input type="submit" value="완료" style="width:160px; height:30px; margin-right:5px;" />

        <a href=@MOK_GET_TOKEN_CSHTML>
            <input type="button" style="width:160px; height:30px; margin-left:5px; margin-bottom:15px;" value='취소' />
        </a>
        <!-- 인증방식이 SMS일 경우에만 사용 START -->
        <h3>(인증번호를 수신하는 경우) 인증번호를 입력 후 완료버튼을 눌러주세요.</h3>
        인증번호 : <input type="text" id="authNumber" name="authNumber" value='' style="width: 245px; height: 20px; margin-bottom: 15px;" /> (인증방식 SMS, LMS일 경우 필수) <br>
        <input type="submit" value="완료" style="width:160px; height:30px; margin-right:5px;" />

        <a href=@MOK_GET_TOKEN_CSHTML>
            <input type="button" style="width:160px; height:30px; margin-left:5px; margin-bottom:15px;" value='취소' />
        </a>
        <!-- 인증방식이 SMS일 경우에만 사용 END -->
    </form>
    <form action=@MOK_REQUEST_CSHTML method="post">
        <input type="hidden" id="MOKAuthResendData" name="MOKAuthResendData" value='' />
        <h3>(재요청은 본인확인 인증 처리 Type 코드가 "SMS"일 경우에만 지원)</h3>
        <button id="resend" name="resend" style="width:335px; height:30px;">재요청</button>
    </form>
    <!-- 인증방식이 ARS 점유인증일 경우에만 사용 END -->
    <form action=@MOK_CALL_CSHTML method="post">
        <input type="hidden" id="MOKCallData" name="MOKCallData" value='' />
        <h3>ARS 전화요청 인증번호 (인증번호를 ARS전화요청시 입력하여 주십시오.)</h3>
        <div>인증번호 : <span id="arsOtpNumber"></span></div>
        <input type="submit" value="전화걸기" style="width:160px; height:30px; margin-right:5px;" />
        <a href=@MOK_REQUEST_CSHTML>
            <input type="button" style="width:160px; height:30px; margin-left:5px; margin-bottom:15px;" value='취소' />
        </a>
    </form>
</body>
</html>

6. (휴대폰본인확인+ARS 이용기관 전용) ARS 점유인증 전화요청

본인확인-API 이용기관중 ARS 점유인증을 사용하는 이용기관의 ARS 점유인증을 사용 ID는 명의인증 이후 ARS 전화걸기 및 ARS 전화를 통한 인증번호 입력을 요청한다.

ARS 점유인증을 사용하지 않는 이용기관은 구현하지 않는 부분입니다.

ARS 점유인증 전화요청의 결과값으로 ARS 전화요청 등록 결과를 수신한다. 이때 ARS 전화는 대부분 10초 이내 사용자의 휴대전화에 전화를 걸게된다.

Info

  • ARS 점유인증시 전화걸기 후 통화는 1번만 가능하며 통화중 3번까지 인증번호 재입력 및 검증 제공
  • 사용자가 전화를 수신하고 종료하게되면 인증번호 미입력시에도 재시도 안됨, ARS인증을 처음부터 다시 진행 필요
  • ARS 점유인증시 전화걸기 후 사용자가 아래 사유로 전화를 받지 못하여 통화실패시 전화걸기를 재요청 가능한 사례
    • 사용자가 휴대폰으로 전화를 받지 않았을 경우
    • 사용자가 휴대폰 통화중으로 인해 전화를 받지 않았을 경우
    • 사용자가 휴대폰 전화통화전 전원버튼등으로 종료하여 전화를 받지 않았을 경우

사용자가 ARS 전화요청을 받지 못하는 경우

  • 사용자의 전화차단앱(‘후스콜’, ‘뭐야이번호’, ’후후’ 등) 사용으로 차단한 경우
  • 사용자의 전화기에 ARS요청 송신번호가 ‘수신차단’으로 등록된 경우
  • 휴대폰 및 통신사 설정에 차단처리가 있는 경우
    • 법인폰 / 선불폰 여부
    • 수발신 정지 여부
    • 통화 시도 위치 국외 여부
    • 지역번호 차단여부
    • 수신차단 / 착신 차단
    • 정보를 부정확하게 입력하거나, 인증 진행 정보가 다른지 여부
    • 통신사의 스팸차단 어플 사용 여부(후후, 후스콜, T전화 등)

  • 본인확인-API 검증 결과요청 정보

    • URL

      • 운영 : https://cert-dir.mobile-ok.com/agent/v1/auth/call

      • 개발 : https://scert-dir.mobile-ok.com/agent/v1/auth/call

    • HTTPS 암호화 통신 : TLS 1.2 이상

    • HTTP 메소드 : POST

    • Charset : utf-8

  • ARS 전화요청 원문 MOKARSCallInfo 생성

    속성 값 필수여부
    encryptMOKToken 인증요청 후 수신받은 암호화된 본인확인-API 거래 토큰 ●

  • 본인확인 ARS 전화요청 JSON 예시

    {
    "encryptMOKToken" : "[hzOoAv60ZlzuAf1km9o8i8wlJo8x2uvBwTlFNItwaCF0EKK2PvHqv+yivqUqvU1d/ShmMyW0vEKG8hw9TlubnN+Tkg...3I5VTJexA8nIsVPa8UCH1kmK8rQ0zX99YgHhzC7wCoGeOEcrENGYGYVUrV/wp2J8lg8KbfCUev/+bDhowIPsa",
}

  • ARS 전화요청 응답 JSON

    • 본인확인 인증결과 JSON 설명

      속성 값 필수여부
      resultCode 응답 결과 코드
      -2000일 경우 성공
      -2000이 아닐 경우 에러처리      		 ●
      resultMsg resultCode 가 2000이 아닐 경우 에러 메시지 ●
      encryptMOKToken 암호화된 본인확인-API 거래 토큰 ●

    • MOKResult 본인확인 인증결과 응답 JSON 예시

      {     
"resultCode":"2000",
"resultMsg":"success",
"encryptMOKToken":"[hzOoAv60ZlzuAf1km9o8i8wlJo8x2uvBwTlFNItwaCF0EKK2PvHqv+yivqUqvU1d/ShmMyW0vEKG8hw9TlubnN+Tkg...3I5VTJexA8nIsVPa8UCH1kmK8rQ0zX99YgHhzC7wCoGeOEcrENGYGYVUrV/wp2J8lg8KbfCUev/+bDhowIPsa"
}

  • 본인확인 ARS전화요청 API 요청 및 응답 예제

    mok_ars_call.jsp
      1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
    <%@page import="java.util.Date"%>
<%@page import="java.text.SimpleDateFormat"%>
<%@page import="com.dreamsecurity.json.JSONException"%>
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<%@ page import="java.io.*" %>
<%@ page import="java.net.HttpURLConnection" %>
<%@ page import="java.net.URL" %>
<%@ page import="java.net.URLEncoder" %>
<%@ page import="java.net.URLDecoder" %>
<%@ page import="com.dreamsecurity.json.JSONObject" %>
<%@ page import="com.dreamsecurity.mobileOK.mobileOKKeyManager" %>
<%@ page import="com.dreamsecurity.mobileOK.MobileOKException" %>

<%!
/* 1. 본인확인 인증결과 MOKConfirm API 또는 MOKResult API 요청 URL */
//private final String MOK_CONFIRM_URL = "https://cert-dir.mobile-ok.com/agent/v1/auth/call";  // 운영
private final String MOK_CONFIRM_URL = "https://scert-dir.mobile-ok.com/agent/v1/auth/call"; // 개발

    /* 재시도 버튼 클릭시 이동 JSP (mobileOK-Request JSP)*/
    private final String MOK_RESULT_JSP = "./mok_api_result.jsp";
    /* 처음페이지 버튼 클릭시 이동 JSP (mobileOK-GetToken JSP)*/
    private final String MOK_GET_TOKEN_JSP = "./mok_api_gettoken.jsp";
    /* 재시도 버튼 클릭시 이동 JSP (mobileOK-Call JSP)*/
    private final String MOK_CALL_JSP = "./mok_ars_call.jsp";    
%>

<%
/* 2. 본인확인 키파일을 통한 비밀키 설정 */
String resultData = "";

    try {
        String MOKCallData = request.getParameter("MOKCallData");
        String encryptMOKToken = request.getParameter("encryptMOKToken");
        String arsOtpNumber = request.getParameter("arsOtpNumber");

        if ((MOKCallData == null || MOKCallData.equals("")) && (encryptMOKToken == null || encryptMOKToken.equals(""))) {
            throw new MobileOKException("-1|본인확인 요청 MOKToken이 없습니다.");
        }

        if(!(MOKCallData == null || MOKCallData.equals(""))) {
            MOKCallData = URLDecoder.decode(MOKCallData, "UTF-8");
            resultData = mobileOK_api_call(MOKCallData, session, request);
        } else if(!(encryptMOKToken == null || encryptMOKToken.equals(""))) {           
            resultData = re_mobileOK_api_call(encryptMOKToken, arsOtpNumber, request.getParameter("publicKey"),  session, request);
        }

    } catch (MobileOKException e) {
        resultData = setErrorMsg(null, e.getMessage());
    }
%>

<%!
/* 본인확인 API 콜요청 예제 함수 */
public String mobileOK_api_call(String MOKCallData, HttpSession session, HttpServletRequest request) throws MobileOKException {
/* 3. 본인확인 검증요청 입력정보 설정 (아래 MOKConfirmRequestToJsonString() 참조) */

        JSONObject MOKCallDataJson = new JSONObject(MOKCallData);

        String MOKCallRequest = MOKCallToJsonString(MOKCallDataJson.getString("encryptMOKToken"));

        String arsOtpNumber = MOKCallDataJson.optString("arsOtpNumber", "");

        /* 4. 본인확인 콜결과 확인 요청 */
        String MOKCallResponse = sendPost(MOK_CONFIRM_URL, MOKCallRequest);

        /* 5. 본인확인 검증요청 API에서 이용할 데이터 설정 */
        JSONObject MOKConfirmData = new JSONObject(MOKCallResponse);
        MOKConfirmData.put("publicKey", MOKCallDataJson.getString("publicKey"));
        MOKConfirmData.put("arsOtpNumber", arsOtpNumber);

        if (!"2000".equals(MOKConfirmData.getString("resultCode"))) {
            return setErrorMsg(MOKConfirmData.getString("resultCode"), MOKConfirmData.getString("resultMsg"));
        } else {
            return MOKConfirmData.toString();
        }
    }

    /* 본인확인 API 전화재요청 예제 함수 */
    public String re_mobileOK_api_call(String encryptMOKToken, String arsOtpNumber, String publicKey, HttpSession session, HttpServletRequest request) throws MobileOKException {
        /* 3. 본인확인 검증요청 입력정보 설정 (아래 MOKConfirmRequestToJsonString() 참조) */        

        /* 3. 본인확인 검증요청 입력정보 설정 (아래 MOKConfirmRequestToJsonString() 참조) */        
        String MOKConfrimRequest = MOKCallToJsonString(encryptMOKToken);

        /* 4. 본인확인 인증결과 확인 요청 */
        String MOKCallResponse = sendPost(MOK_CONFIRM_URL, MOKConfrimRequest);

        JSONObject MOKConfirmData = new JSONObject(MOKCallResponse);
        MOKConfirmData.put("publicKey", publicKey);
        MOKConfirmData.put("arsOtpNumber", arsOtpNumber);

        if (!"2000".equals(MOKConfirmData.getString("resultCode"))) {
            return setErrorMsg(MOKConfirmData.getString("resultCode"), MOKConfirmData.getString("resultMsg"));
        } else {
            return MOKConfirmData.toString();
        }
    }

    /* 본인확인-API 콜요청 정보 */
    public String MOKCallToJsonString(
            String encryptMOKToken
        ) throws MobileOKException {        
        JSONObject MOKconfirmRequestJson = new JSONObject();
        MOKconfirmRequestJson.put("encryptMOKToken", encryptMOKToken);

        return MOKconfirmRequestJson.toString();
    }

    /* 본인확인 서버 통신 예제 함수 */
    public String sendPost(String dest, String jsonData) throws MobileOKException {
        HttpURLConnection connection = null;
        DataOutputStream dataOutputStream = null;
        BufferedReader bufferedReader = null;

        try {
            URL url = new URL(dest);
            connection = (HttpURLConnection) url.openConnection();
            connection.setRequestMethod("POST");
            connection.setRequestProperty("Content-Type", "application/json;charset=UTF-8");
            connection.setDoOutput(true);

            dataOutputStream = new DataOutputStream(connection.getOutputStream());
            dataOutputStream.write(jsonData.getBytes("UTF-8"));

            bufferedReader = new BufferedReader(new InputStreamReader(connection.getInputStream()));
            StringBuffer responseData = new StringBuffer();
            String info;
            while ((info = bufferedReader.readLine()) != null) {
                responseData.append(info);
            }
            return responseData.toString();
        } catch (FileNotFoundException e) {
            throw new MobileOKException("-5|MOK_CONFIRM_URL을 확인해주세요.");
        } catch (JSONException e) {
            throw new MobileOKException("JSON PARSER ERROR");
        } catch(IOException e) {
            throw new MobileOKException("통신 오류");
        } finally {
            try {
                if (bufferedReader != null) {
                    bufferedReader.close();
                }

                if (dataOutputStream != null) {
                    dataOutputStream.close();
                }

                if (connection != null) {
                    connection.disconnect();
                }
            } catch (Exception e) {
                throw new MobileOKException("connection close ERROR");
            }
        }
    }

    private String setErrorMsg(String resultCode , String errorMsg) {
        JSONObject errorJson = new JSONObject();

        if(resultCode != null) {
            errorJson.put("resultCode", resultCode);
        }

        errorJson.put("resultMsg", errorMsg);

        return errorJson.toString();
    }
%>

<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>mok_ars_call</title>
<script>
    const MOKAuthRequestJson = decodeURIComponent('<%= resultData %>');
    const MOKAuthRequestJsonObject = JSON.parse(MOKAuthRequestJson);

    document.addEventListener("DOMContentLoaded", function () {
        if (MOKAuthRequestJsonObject.resultCode != '2000') {
            /* 오류발생시 */
            window.alert(MOKAuthRequestJsonObject.resultCode + ', ' + MOKAuthRequestJsonObject.resultMsg);                
        } else {
            /* 정장작동시 */
            document.getElementById("MOKConfirmData").value = encodeURIComponent(MOKAuthRequestJson);
            document.getElementById("encryptMOKToken").value = MOKAuthRequestJsonObject.encryptMOKToken;
            document.getElementById("publicKey").value = MOKAuthRequestJsonObject.publicKey;
            document.getElementById("arsOtpNumber").value = MOKAuthRequestJsonObject.arsOtpNumber;
            document.getElementById("authNumber").innerText = MOKAuthRequestJsonObject.arsOtpNumber;
        }
    });
</script>
</head>
<body>
    <div>인증번호 : <span id="authNumber"></span></div>

    <form action='<%= MOK_RESULT_JSP %>' method="post">
        <input type="hidden" id="MOKConfirmData" name="MOKConfirmData" value='' />
        <input type="submit" value="검증" style="width:160px; height:30px; margin-right:5px;" />
        <a href='<%= MOK_GET_TOKEN_JSP %>'> 
            <input type="button" style="width:160px; height:30px; margin-left:5px; margin-bottom:15px;" value='취소' />
        </a>
    </form>
    <form action='<%= MOK_CALL_JSP %>' method="post">
        <input type="hidden" id="encryptMOKToken" name="encryptMOKToken" value='' />
        <input type="hidden" id="arsOtpNumber" name="arsOtpNumber" value='' />
        <input type="hidden" id="publicKey" name="publicKey" value='' />
        <input type="submit" value="전화 재시도" style="width:160px; height:30px; margin-right:5px;" />      
    </form>

</body>
</html>
    mok_ars_call.jsp
      1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
    <%@page import="org.bouncycastle.jsse.provider.BouncyCastleJsseProvider"%>
<%@page import="java.security.SecureRandom"%>
<%@page import="javax.net.ssl.HttpsURLConnection"%>
<%@page import="javax.net.ssl.SSLContext"%>
<%@page import="java.util.Date"%>
<%@page import="java.text.SimpleDateFormat"%>
<%@page import="com.dreamsecurity.json.JSONException"%>
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<%@ page import="java.io.*" %>
<%@ page import="java.net.HttpURLConnection" %>
<%@ page import="java.net.URL" %>
<%@ page import="java.net.URLEncoder" %>
<%@ page import="java.net.URLDecoder" %>
<%@ page import="com.dreamsecurity.json.JSONObject" %>
<%@ page import="com.dreamsecurity.mobileOK.mobileOKKeyManager" %>
<%@ page import="com.dreamsecurity.mobileOK.MobileOKException" %>

<%!
    /* 1. 본인확인 인증결과 MOKConfirm API 또는 MOKResult API 요청 URL */
    //private final String MOK_CONFIRM_URL = "https://cert-dir.mobile-ok.com/agent/v1/auth/call";  // 운영
    private final String MOK_CONFIRM_URL = "https://scert-dir.mobile-ok.com/agent/v1/auth/call"; // 개발

    /* 재시도 버튼 클릭시 이동 JSP (mobileOK-Request JSP)*/
    private final String MOK_RESULT_JSP = "./mok_api_result.jsp";
    /* 처음페이지 버튼 클릭시 이동 JSP (mobileOK-GetToken JSP)*/
    private final String MOK_GET_TOKEN_JSP = "./mok_api_gettoken.jsp";

    private final String MOK_CALL_JSP = "./mok_ars_call.jsp";    
%>

<%
    /* 2. 본인확인 키파일을 통한 비밀키 설정 */
    String resultData = "";

    try {
        String MOKCallData = request.getParameter("MOKCallData");
        String encryptMOKToken = request.getParameter("encryptMOKToken");
        String arsOtpNumber = request.getParameter("arsOtpNumber");

        if ((MOKCallData == null || MOKCallData.equals("")) && (encryptMOKToken == null || encryptMOKToken.equals(""))) {
            throw new MobileOKException("-1|본인확인 요청 MOKToken이 없습니다.");
        }

        if(!(MOKCallData == null || MOKCallData.equals(""))) {
            MOKCallData = URLDecoder.decode(MOKCallData, "UTF-8");
            resultData = mobileOK_api_call(MOKCallData, session, request);
        } else if(!(encryptMOKToken == null || encryptMOKToken.equals(""))) {           
            resultData = re_mobileOK_api_call(encryptMOKToken, arsOtpNumber, request.getParameter("publicKey"),  session, request);
        }
    } catch (MobileOKException e) {
        resultData = setErrorMsg(null, e.getMessage());
    }
%>

<%!
    /* 본인확인 API 콜요청 예제 함수 */
    public String mobileOK_api_call(String MOKCallData, HttpSession session, HttpServletRequest request) throws MobileOKException {
        /* 3. 본인확인 검증요청 입력정보 설정 (아래 MOKConfirmRequestToJsonString() 참조) */        

        JSONObject MOKCallDataJson = new JSONObject(MOKCallData);

        String MOKCallRequest = MOKCallToJsonString(MOKCallDataJson.getString("encryptMOKToken"));

        String arsOtpNumber = MOKCallDataJson.optString("arsOtpNumber", "");

        /* 4. 본인확인 콜결과 확인 요청 */
        String MOKCallResponse = sendPost(MOK_CONFIRM_URL, MOKCallRequest);

        /* 5. 본인확인 검증요청 API에서 이용할 데이터 설정 */
        JSONObject MOKConfirmData = new JSONObject(MOKCallResponse);
        MOKConfirmData.put("publicKey", MOKCallDataJson.getString("publicKey"));
        MOKConfirmData.put("arsOtpNumber", arsOtpNumber);

        if (!"2000".equals(MOKConfirmData.getString("resultCode"))) {
            return setErrorMsg(MOKConfirmData.getString("resultCode"), MOKConfirmData.getString("resultMsg"));
        } else {
            return MOKConfirmData.toString();
        }
    }

    /* 본인확인 API 전화재요청 예제 함수 */
    public String re_mobileOK_api_call(String encryptMOKToken, String arsOtpNumber, String publicKey, HttpSession session, HttpServletRequest request) throws MobileOKException {
        /* 3. 본인확인 검증요청 입력정보 설정 (아래 MOKConfirmRequestToJsonString() 참조) */        

        /* 3. 본인확인 검증요청 입력정보 설정 (아래 MOKConfirmRequestToJsonString() 참조) */        
        String MOKConfrimRequest = MOKCallToJsonString(encryptMOKToken);

        /* 4. 본인확인 인증결과 확인 요청 */
        String MOKCallResponse = sendPost(MOK_CONFIRM_URL, MOKConfrimRequest);

        JSONObject MOKConfirmData = new JSONObject(MOKCallResponse);
        MOKConfirmData.put("publicKey", publicKey);
        MOKConfirmData.put("arsOtpNumber", arsOtpNumber);

        if (!"2000".equals(MOKConfirmData.getString("resultCode"))) {
            return setErrorMsg(MOKConfirmData.getString("resultCode"), MOKConfirmData.getString("resultMsg"));
        } else {
            return MOKConfirmData.toString();
        }
    }

    /* 본인확인-API 콜요청 정보 */
    public String MOKCallToJsonString(
            String encryptMOKToken
        ) throws MobileOKException {        
        JSONObject MOKconfirmRequestJson = new JSONObject();
        MOKconfirmRequestJson.put("encryptMOKToken", encryptMOKToken);

        return MOKconfirmRequestJson.toString();
    }

    /* 본인확인 서버 통신 예제 함수 */
    private String sendPost(String dest, String json) throws MobileOKException {
        HttpsURLConnection connection = null; 
        DataOutputStream dataOutputStream = null;
        BufferedReader bufferedReader = null;
        StringBuffer responseData = null;

        try {
            SSLContext sslContext = SSLContext.getInstance("TLSv1.2", new BouncyCastleJsseProvider());
            sslContext.init(null, null, new SecureRandom());

            URL url = new URL(dest);
            connection = (HttpsURLConnection) url.openConnection();
            connection.setSSLSocketFactory(sslContext.getSocketFactory());

            connection.setRequestMethod("POST");
            connection.setRequestProperty("Content-Type", "application/json;charset=UTF-8");
            connection.setDoOutput(true);

            dataOutputStream = new DataOutputStream(connection.getOutputStream());
            dataOutputStream.writeBytes(json.toString());

            bufferedReader = new BufferedReader(
                    new InputStreamReader(connection.getInputStream())
            );
            responseData = new StringBuffer();
            String info;
            while ((info = bufferedReader.readLine()) != null) {
                responseData.append(info);
            }

            return responseData.toString();
        } catch (FileNotFoundException e) {
            throw new MobileOKException("MOK_GET_TOKEN_URL을 확인해 주세요.");
        } catch (JSONException e) {
            e.printStackTrace();
        } catch(IOException e) {
            e.printStackTrace();
        } catch(Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (bufferedReader != null) {
                    bufferedReader.close();
                }

                if (dataOutputStream != null) {
                    dataOutputStream.close();
                }

                if (connection != null) {
                    connection.disconnect();
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

        return null;
    }

    private String setErrorMsg(String resultCode , String errorMsg) {
        JSONObject errorJson = new JSONObject();

        if(resultCode != null) {
            errorJson.put("resultCode", resultCode);
        }

        errorJson.put("resultMsg", errorMsg);

        return errorJson.toString();
    }
%>

<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>mok_ars_call</title>
<script>
    const MOKAuthRequestJson = decodeURIComponent('<%= resultData %>');
    const MOKAuthRequestJsonObject = JSON.parse(MOKAuthRequestJson);

    document.addEventListener("DOMContentLoaded", function () {
        if (MOKAuthRequestJsonObject.resultCode != '2000') {
            /* 오류발생시 */
            window.alert(MOKAuthRequestJsonObject.resultCode + ', ' + MOKAuthRequestJsonObject.resultMsg);                
        } else {
            /* 정장작동시 */
            document.getElementById("MOKConfirmData").value = encodeURIComponent(MOKAuthRequestJson);
            document.getElementById("encryptMOKToken").value = MOKAuthRequestJsonObject.encryptMOKToken;
            document.getElementById("publicKey").value = MOKAuthRequestJsonObject.publicKey;
            document.getElementById("arsOtpNumber").value = MOKAuthRequestJsonObject.arsOtpNumber;
            document.getElementById("authNumber").innerText = MOKAuthRequestJsonObject.arsOtpNumber;
        }
    });
</script>
</head>
<body>
    <div>인증번호 : <span id="authNumber"></span></div>

    <form action='<%= MOK_RESULT_JSP %>' method="post">
        <input type="hidden" id="MOKConfirmData" name="MOKConfirmData" value='' />
        <input type="submit" value="검증" style="width:160px; height:30px; margin-right:5px;" />
        <a href='<%= MOK_GET_TOKEN_JSP %>'> 
            <input type="button" style="width:160px; height:30px; margin-left:5px; margin-bottom:15px;" value='취소' />
        </a>
    </form>
    <form action='<%= MOK_CALL_JSP %>' method="post">
        <input type="hidden" id="encryptMOKToken" name="encryptMOKToken" value='' />
        <input type="hidden" id="arsOtpNumber" name="arsOtpNumber" value='' />
        <input type="hidden" id="publicKey" name="publicKey" value='' />
        <input type="submit" value="전화 재시도" style="width:160px; height:30px; margin-right:5px;" />      
    </form>

</body>
</html>
    mok_ars_call.php
      1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
    <?php
    // 각 버전 별 맞는 mobileOKManager-php를 사용
    $mobileOK_path = "./mobileOK_manager_phpseclib_v3.0_v1.0.2.php";

    if(!file_exists($mobileOK_path)) {
        die('1000|mobileOK_Key_Manager파일이 존재하지 않습니다.');
    } else {
        require_once $mobileOK_path;
    }
?>
<?php
    // local시간 설정이 다르게 될  수 있음으로 기본 시간 설정을 서울로 해놓는다.
    date_default_timezone_set('Asia/Seoul');
?>
<?php
    /* 1. 본인확인 인증결과 MOKConfirm API 또는 MOKResult API 요청 URL */
    $MOK_CALL_URL = "https://scert-dir.mobile-ok.com/agent/v1/auth/call";  // 개발
    // $MOK_CALL_URL = "https://cert-dir.mobile-ok.com/agent/v1/auth/call";  // 운영

    /* 검증 버튼 클릭시 이동 PHP (mobileOK-Request PHP)*/
    $MOK_API_RESULT_PHP = "./mok_api_result.php";
    /* 취소 버튼 클릭시 이동 PHP (mobileOK-GetToken PHP)*/
    $MOK_API_GET_TOKEN_PHP = "./mok_api_gettoken.php";
    /* 재시도 버튼 클릭시 이동 PHP (mobileOK-CALL PHP) => ARS일 경우*/
    $MOK_CALL_PHP = "./mok_ars_call.php";

    if(!($_POST['MOKCallData'] == null || $_POST['MOKCallData'] == "")) {
        $MOK_RESULT = mobileOK_api_call($MOK_CALL_URL);
    } else if(!($_POST['encryptMOKToken'] == null || $_POST['encryptMOKToken'] == "")) {
        $MOK_RESULT = re_mobileOK_api_call($MOK_CALL_URL);
    }
?>
<?php
    /* 본인확인 API 콜요청 예제 함수 */
    function mobileOK_api_call($MOK_CALL_URL) {
        /* 3. 본인확인 콜요청 입력정보 설정 (아래 MOKConfirmRequestToJsonString() 참조) */

        $MOK_call_data = json_decode($_POST['MOKCallData']);

        $MOK_call_request = MOKCallToJsonString($MOK_call_data->encryptMOKToken);

        $MOK_call_response = sendPost($MOK_call_request, $MOK_CALL_URL);

        $MOKConfirmData = json_decode($MOK_call_response);

        if ('2000' != $MOKConfirmData->resultCode) {
            $MOKConfirmFailData = array(
                'resultCode' => $MOKConfirmData -> resultCode
                , 'resultMsg' => $MOKConfirmData -> resultMsg
            );

            return json_encode($MOKConfirmFailData, JSON_UNESCAPED_SLASHES);
        } else {
            $MOKConfirmSuccessData = array(
                'resultCode' => $MOKConfirmData -> resultCode
                , 'resultMsg' => $MOKConfirmData -> resultMsg
                , 'encryptMOKToken' => $MOKConfirmData -> encryptMOKToken
                , 'publicKey' => $MOK_call_data -> publicKey
                , 'arsOtpNumber' => $MOK_call_data -> arsOtpNumber
            );
            return json_encode($MOKConfirmSuccessData, JSON_UNESCAPED_SLASHES);
        }
    }

    /* 본인확인 API 콜 재요청 예제 함수 */
    function re_mobileOK_api_call($MOK_CALL_URL) {
        /* 3. 본인확인 콜 재요청 입력정보 설정 (아래 MOKConfirmRequestToJsonString() 참조) */

        $MOK_call_request = MOKCallToJsonString($_POST['encryptMOKToken']);

        $MOK_call_response = sendPost($MOK_call_request, $MOK_CALL_URL);

        $MOKConfirmData = json_decode($MOK_call_response);

        if ('2000' != $MOKConfirmData->resultCode) {
            $MOKConfirmFailData = array(
                'resultCode' => $MOKConfirmData -> resultCode
                , 'resultMsg' => $MOKConfirmData -> resultMsg
            );

            return json_encode($MOKConfirmFailData, JSON_UNESCAPED_SLASHES);
        } else {
            $MOKConfirmSuccessData = array(
                'resultCode' => $MOKConfirmData -> resultCode
                , 'resultMsg' => $MOKConfirmData -> resultMsg
                , 'encryptMOKToken' => $MOKConfirmData -> encryptMOKToken
                , 'publicKey' => $_POST['publicKey']
                , 'arsOtpNumber' => $_POST['arsOtpNumber']
            );
            return json_encode($MOKConfirmSuccessData, JSON_UNESCAPED_SLASHES);
        }
    }

    /* 본인확인-API 검증요청 정보 */
    function MOKCallToJsonString($encryptMOKToken) {
        $confirm_request_array = array(
            'encryptMOKToken'=> $encryptMOKToken
        );

        return json_encode($confirm_request_array, JSON_UNESCAPED_SLASHES);
    }

    /* 본인확인 서버 통신 예제 함수 */
    function sendPost($data, $url) {
        $curl = curl_init();                                                              // curl 초기화
        curl_setopt($curl, CURLOPT_URL, $url);                                            // 데이터를 전송 할 URL
        curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);                                 // 요청결과를 문자열로 반환
        curl_setopt($curl, CURLOPT_HTTPHEADER, array('Content-Type: application/json'));  // 전송 ContentType을 Json형식으로 설정
        curl_setopt($curl, CURLOPT_SSL_VERIFYPEER, false);                                // 원격 서버의 인증서가 유효한지 검사 여부
        curl_setopt($curl, CURLOPT_POSTFIELDS, $data);                                    // POST DATA
        curl_setopt($curl, CURLOPT_POST, true);                                           // POST 전송 여부
        $response = curl_exec($curl);                                                     // 전송
        curl_close($curl);                                                                // 연결해제

        return $response;
    }
?>

<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>mok_ars_call</title>
<script>
    const MOKAuthRequestJson = decodeURIComponent('<?php echo $MOK_RESULT ?>');
    const MOKAuthRequestJsonObject = JSON.parse(MOKAuthRequestJson);

    document.addEventListener("DOMContentLoaded", function () {
        if (MOKAuthRequestJsonObject.resultCode != '2000') {
            /* 오류발생시 */
            window.alert(MOKAuthRequestJsonObject.resultCode + ', ' + MOKAuthRequestJsonObject.resultMsg);                
        } else {
            /* 정장작동시 */
            document.getElementById("MOKConfirmData").value = MOKAuthRequestJson;
            document.getElementById("encryptMOKToken").value = MOKAuthRequestJsonObject.encryptMOKToken;
            document.getElementById("publicKey").value = MOKAuthRequestJsonObject.publicKey;
            document.getElementById("arsOtpNumber").value = MOKAuthRequestJsonObject.arsOtpNumber;
            document.getElementById("authNumber").innerText = MOKAuthRequestJsonObject.arsOtpNumber;
        }
    });
</script>
</head>
<body>
    <div>인증번호 : <span id="authNumber"></span></div>

    <form action='<?php echo $MOK_API_RESULT_PHP ?>' method="post">
        <input type="hidden" id="MOKConfirmData" name="MOKConfirmData" value='' />
        <input type="submit" value="검증" style="width:160px; height:30px; margin-right:5px;" />
        <a href='<?php echo $MOK_API_GET_TOKEN_PHP ?>'> 
            <input type="button" style="width:160px; height:30px; margin-left:5px; margin-bottom:15px;" value='취소' />
        </a>
    </form>
    <form action='<?php echo $MOK_CALL_PHP ?>' method="post">
        <input type="hidden" id="encryptMOKToken" name="encryptMOKToken" value='' />
        <input type="hidden" id="arsOtpNumber" name="arsOtpNumber" value='' />
        <input type="hidden" id="publicKey" name="publicKey" value='' />
        <input type="submit" value="전화 재시도" style="width:160px; height:30px; margin-right:5px;" />      
    </form>

</body>
</html>
    views/mok_ars_call.ejs
     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
    <!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>mok_ars_call</title>
<script>
    const MOKAuthRequestJson = decodeURIComponent('<%- resultData %>');
    const MOKAuthRequestJsonObject = JSON.parse(MOKAuthRequestJson);

    document.addEventListener("DOMContentLoaded", function () {
        if (MOKAuthRequestJsonObject.resultCode != '2000') {
            /* 오류발생시 */
            window.alert(MOKAuthRequestJsonObject.resultCode + ', ' + MOKAuthRequestJsonObject.resultMsg);                
        } else {
            /* 정장작동시 */
            document.getElementById("MOKConfirmData").value = encodeURIComponent(MOKAuthRequestJson);
            document.getElementById("encryptMOKToken").value = MOKAuthRequestJsonObject.encryptMOKToken;
            document.getElementById("publicKey").value = MOKAuthRequestJsonObject.publicKey;
            document.getElementById("arsOtpNumber").value = MOKAuthRequestJsonObject.arsOtpNumber;
            document.getElementById("authNumber").innerText = MOKAuthRequestJsonObject.arsOtpNumber;
        }
    });
</script>
</head>
<body>
    <div>인증번호 : <span id="authNumber"></span></div>

    <form action='<%- reqUrl.MOKConfirmUri %>' method="post">
        <input type="hidden" id="MOKConfirmData" name="MOKConfirmData" value='' />
        <input type="submit" value="검증" style="width:160px; height:30px; margin-right:5px;" />
        <a href='<%- reqUrl.MOKGetTokenUri %>'> 
            <input type="button" style="width:160px; height:30px; margin-left:5px; margin-bottom:15px;" value='취소' />
        </a>
    </form>
    <form action='<%- reqUrl.MOKCallUri %>' method="post">
        <input type="hidden" id="encryptMOKToken" name="encryptMOKToken" value='' />
        <input type="hidden" id="arsOtpNumber" name="arsOtpNumber" value='' />
        <input type="hidden" id="publicKey" name="publicKey" value='' />
        <input type="submit" value="전화 재시도" style="width:160px; height:30px; margin-right:5px;" />      
    </form>

</body>
</html>
    mok_ars_call.aspx
     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
    <%@ Page Language="C#" AutoEventWireup="true" CodeBehind="mok_ars_call.aspx.cs" Inherits="mok_ars_call" %>
<%@ Import Namespace="System" %>

<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>mok_ars_call</title>
<script>
    const MOKAuthRequestJson = decodeURIComponent('<%= resultData %>');
    const MOKAuthRequestJsonObject = JSON.parse(MOKAuthRequestJson);

    document.addEventListener("DOMContentLoaded", function () {
        if (MOKAuthRequestJsonObject.resultCode != '2000') {
            /* 오류발생시 */
            window.alert(MOKAuthRequestJsonObject.resultCode + ', ' + MOKAuthRequestJsonObject.resultMsg);                
        } else {
            /* 정장작동시 */
            document.getElementById("MOKConfirmData").value = encodeURIComponent(MOKAuthRequestJson);
            document.getElementById("encryptMOKToken").value = MOKAuthRequestJsonObject.encryptMOKToken;
            document.getElementById("publicKey").value = MOKAuthRequestJsonObject.publicKey;
            document.getElementById("arsOtpNumber").value = MOKAuthRequestJsonObject.arsOtpNumber;
            document.getElementById("authNumber").innerText = MOKAuthRequestJsonObject.arsOtpNumber;
        }
    });
</script>
</head>
<body>
    <div>인증번호 : <span id="authNumber"></span></div>

    <form action='<%= MOK_RESULT_ASPX %>' method="post">
        <input type="hidden" id="MOKConfirmData" name="MOKConfirmData" value='' />
        <input type="submit" value="검증" style="width:160px; height:30px; margin-right:5px;" />
        <a href='<%= MOK_GET_TOKEN_ASPX %>'> 
            <input type="button" style="width:160px; height:30px; margin-left:5px; margin-bottom:15px;" value='취소' />
        </a>
    </form>
    <form action='<%= MOK_CALL_ASPX %>' method="post">
        <input type="hidden" id="encryptMOKToken" name="encryptMOKToken" value='' />
        <input type="hidden" id="arsOtpNumber" name="arsOtpNumber" value='' />
        <input type="hidden" id="publicKey" name="publicKey" value='' />
        <input type="submit" value="전화 재시도" style="width:160px; height:30px; margin-right:5px;" />
    </form>

</body>
</html>
    mok_ars_call.aspx.cs
      1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
    using Newtonsoft.Json.Linq;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net;
using System.Text;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;

public partial class mok_ars_call : Page
{
    /*1. 본인확인 인증결과 MOKAuth API 또는 MOKResend API 요청 URL*/
    //private string MOK_CALL_URL = "https://cert-dir.mobile-ok.com/agent/v1/auth/call"; // 개발
    protected static string MOK_CALL_URL = "https://scert-dir.mobile-ok.com/agent/v1/auth/call"; // 개발

    // 검증 버튼 클릭시 이동 aspx (mobileOK-Result aspx)//
    protected static string MOK_RESULT_ASPX = "/mok_api_result.aspx";
    /* 처음페이지 버튼 클릭시 이동 JSP (mobileOK-GetToken aspx)*/
    protected static string MOK_GET_TOKEN_ASPX = "/mok_api_gettoken.aspx";
    // 전화재시도 버튼 클릭시 이동 aspx (mobileOK-CALL aspx)//
    protected static string MOK_CALL_ASPX = "/mok_ars_call.aspx";

    protected string resultData = "";

    protected void Page_Load(object sender, EventArgs e)
    {
        string MOKCallData = HttpContext.Current.Request.Form["MOKCallData"];
        string encryptMOKToken = HttpContext.Current.Request.Form["encryptMOKToken"];

        if ((MOKCallData == null || MOKCallData.Equals("")) && (encryptMOKToken == null || encryptMOKToken.Equals("")))
        {
            resultData = SetErrorMsg("", "-1|본인확인 요청 MOKToken이 없습니다.");
            return;
        }

        if (!(MOKCallData == null || MOKCallData.Equals("")))
        {
            MOKCallData = HttpUtility.UrlDecode(MOKCallData, System.Text.Encoding.UTF8);
            resultData = mobileOK_api_call(MOKCallData);
        }
        else if (!(encryptMOKToken == null || encryptMOKToken.Equals("")))
        {
            string arsOtpNumber = HttpContext.Current.Request.Form["arsOtpNumber"];
            string publicKey = HttpContext.Current.Request.Form["publicKey"];

            resultData = re_mobileOK_api_call(encryptMOKToken, arsOtpNumber, publicKey);
        }
    }

    /* 본인확인 API 콜요청 예제 함수 */
    public string mobileOK_api_call(string MOKCallData)
    {
        JObject MOKCallDataJson = JObject.Parse(MOKCallData);
        string MOKCallRequest = MOKCallToJsonString(MOKCallDataJson["encryptMOKToken"].ToString());

        string MOKCallResponse = SendPost(MOK_CALL_URL, MOKCallRequest);

        JObject MOKConfirmData = JObject.Parse(MOKCallResponse);

        if("2000".Equals(MOKConfirmData["resultCode"].ToString()))
        {
            MOKConfirmData["publicKey"] = MOKCallDataJson["publicKey"].ToString();
            MOKConfirmData["arsOtpNumber"] = MOKCallDataJson["arsOtpNumber"].ToString();

            string MOKConfirmDataString = HttpUtility.UrlEncode(MOKConfirmData.ToString());
            MOKConfirmDataString = MOKConfirmDataString.Replace("+", string.Empty);

            return MOKConfirmDataString;
        } else
        {
            return SetErrorMsg(MOKConfirmData["resultCode"].ToString(), MOKConfirmData["resultMsg"].ToString());
        }
    }

    /* 본인확인 API 콜재요청 예제 함수 */
    public string re_mobileOK_api_call(string encryptMOKToken, string arsOtpNumber, string publicKey)
    {
        string MOKCallRequest = MOKCallToJsonString(encryptMOKToken);

        string MOKCallResponse = SendPost(MOK_CALL_URL, MOKCallRequest);

        JObject MOKConfirmData = JObject.Parse(MOKCallResponse);

        if ("2000".Equals(MOKConfirmData["resultCode"].ToString()))
        {
            MOKConfirmData["publicKey"] = publicKey;
            MOKConfirmData["arsOtpNumber"] = arsOtpNumber;

            string MOKConfirmDataString = HttpUtility.UrlEncode(MOKConfirmData.ToString());
            MOKConfirmDataString = MOKConfirmDataString.Replace("+", string.Empty);

            return MOKConfirmDataString;
        }
        else
        {
            return SetErrorMsg(MOKConfirmData["resultCode"].ToString(), MOKConfirmData["resultMsg"].ToString());
        }
    }

    /* 본인확인-API 콜요청 정보 */
    public string MOKCallToJsonString(string encryptMOKToken)
    {
        JObject MOKconfirmRequestJson = new JObject();
        MOKconfirmRequestJson["encryptMOKToken"] = encryptMOKToken;

        return MOKconfirmRequestJson.ToString();
    }

    private string SetErrorMsg(string resultCode, string errorMsg)
    {
        JObject errorJson = new JObject();
        errorJson["resultCode"] = resultCode;
        errorJson["resultMsg"] = errorMsg;
        string errJson = HttpUtility.UrlEncode(errorJson.ToString());
        errJson = errJson.Replace("+", " ");
        return errJson;
    }

    /* 본인확인 서버 통신 예제 함수 */
    private string SendPost(string url, string json)
    {
        SecurityProtocolType originalProtocol = ServicePointManager.SecurityProtocol;
        try
        {
            ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12;
            HttpWebRequest request = (HttpWebRequest)WebRequest.Create(url);
            request.Method = "POST";
            request.ContentType = "application/json";

            byte[] data = Encoding.UTF8.GetBytes(json);
            request.ContentLength = data.Length;

            using (Stream stream = request.GetRequestStream())
            {
                stream.Write(data, 0, data.Length);
            }

            using (HttpWebResponse response = (HttpWebResponse)request.GetResponse())
            {
                if (response.StatusCode == HttpStatusCode.OK)
                {
                    using (StreamReader reader = new StreamReader(response.GetResponseStream(), Encoding.UTF8))
                    {
                        return reader.ReadToEnd();
                    }
                }
                else
                {
                    return null;
                }
            }
        }
        finally
        {
            // 기존 TLS 설정 복원
            ServicePointManager.SecurityProtocol = originalProtocol;
        }
    }
}
    CallController.cs
      1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
    using Microsoft.AspNetCore.Mvc;
using mokcrypto;
using Newtonsoft.Json.Linq;
using Newtonsoft.Json;
using System.Text;
using System.Web;
using System.Security.Authentication;
using System.Net.Http;
using Microsoft.Extensions.Logging;
using System.Threading.Tasks;
using System;
using System.IO;
using System.Collections.Generic;
using System.Text.Json.Nodes;
using System.Security.Cryptography.X509Certificates;

namespace AspNetCoreAllInOne.Controllers
{
    public class CallController : Controller
    {
        /* 1. 본인확인 인증결과 MOKConfirm API 또는 MOKResult API 요청 URL */
        //private string MOK_CALL_URL = "https://cert-dir.mobile-ok.com/agent/v1/auth/call";  // 운영
        private static string MOK_CALL_URL = "https://scert-dir.mobile-ok.com/agent/v1/auth/call"; // 개발

        [HttpPost]
        public async Task<IActionResult> mok_ars_call()
        {
            /* 2. 본인확인 서비스 함수 초기화 */
            MobileOkKeyManager mobileOK = new MobileOkKeyManager();

            string MOKCallData = HttpContext.Request.Form["MOKCallData"];
            string encryptMOKToken = HttpContext.Request.Form["encryptMOKToken"];

            if (!(MOKCallData == null || MOKCallData.Equals("")))
            {
                MOKCallData = HttpUtility.UrlDecode(MOKCallData, System.Text.Encoding.UTF8);

                ViewData["message"] = await mobileOK_ars_call(MOKCallData);

                return View();
            }
            else if (!(encryptMOKToken == null || encryptMOKToken.Equals("")))
            {
                string arsOtpNumber = HttpContext.Request.Form["arsOtpNumber"];
                string publicKey = HttpContext.Request.Form["publicKey"];

                ViewData["message"] = await re_mobileOK_ars_call(encryptMOKToken, arsOtpNumber, publicKey);

                return View();
            }
            else
            {
                ViewData["message"] = "-1|본인확인 요청 MOKToken이 없습니다.";
                return View();
            }
        }

        public async Task<string> mobileOK_ars_call(string MOKCallData)
        {
            JObject MOKCallDataJson = JObject.Parse(MOKCallData);
            string MOKCallRequest = MOKCallToJsonString(MOKCallDataJson["encryptMOKToken"].ToString());

            string MOKCallResponse = await SendPost(MOK_CALL_URL, MOKCallRequest);

            JObject MOKConfirmData = JObject.Parse(MOKCallResponse);

            if ("2000".Equals(MOKConfirmData["resultCode"].ToString()))
            {
                MOKConfirmData["publicKey"] = MOKCallDataJson["publicKey"].ToString();
                MOKConfirmData["arsOtpNumber"] = MOKCallDataJson["arsOtpNumber"].ToString();

                return MOKConfirmData.ToString();
            }
            else
            {
                return JsonConvert.SerializeObject(MOKConfirmData);
            }
        }

        public async Task<string> re_mobileOK_ars_call(string encryptMOKToken, string arsOtpNumber, string publicKey)
        {
            string MOKCallRequest = MOKCallToJsonString(encryptMOKToken);

            string MOKCallResponse = await SendPost(MOK_CALL_URL, MOKCallRequest);

            JObject MOKConfirmData = JObject.Parse(MOKCallResponse);

            if ("2000".Equals(MOKConfirmData["resultCode"].ToString()))
            {
                MOKConfirmData["publicKey"] = publicKey;
                MOKConfirmData["arsOtpNumber"] = arsOtpNumber;

                string MOKConfirmDataString = HttpUtility.UrlEncode(MOKConfirmData.ToString());
                MOKConfirmDataString = MOKConfirmDataString.Replace("+", string.Empty);

                return MOKConfirmDataString;
            }
            else
            {
                return JsonConvert.SerializeObject(MOKConfirmData);
            }
        }

        /* 본인확인-API 콜요청 정보 */
        public string MOKCallToJsonString(string encryptMOKToken)
        {
            JObject MOKconfirmRequestJson = new JObject();
            MOKconfirmRequestJson["encryptMOKToken"] = encryptMOKToken;

            return MOKconfirmRequestJson.ToString();
        }

        /* 본인확인 서버 통신 예제 함수 */
        private async Task<string> SendPost(string url, string json)
        {
            try
            {
                HttpClient client = new HttpClient();

                var content = new StringContent(json, System.Text.Encoding.UTF8, "application/json");

                var response = await client.PostAsync(url, content);

                if (response.IsSuccessStatusCode)
                {
                    string responseString = await response.Content.ReadAsStringAsync();
                    return responseString;
                }
                else
                {
                    return null;
                }
            }
            catch (HttpRequestException ex)
            {
                Console.WriteLine("HttpRequestException: " + ex.Message);
                return null;
            }
            catch (TaskCanceledException ex)
            {
                Console.WriteLine("TaskCanceledException: " + ex.Message);
                return null;
            }
            catch (IOException ex)
            {
                Console.WriteLine("IOException: " + ex.Message);
                return null;
            }
        }
    }
}
    mok_ars_call.cshtml
     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
    @{
    // 검증 버튼 클릭시 이동
    string MOK_RESULT_CSHTML = "./mok_api_result";
    // 취소 버튼 클릭시 이동
    string MOK_GET_TOKEN_CSHTML = "./mok_api_gettoken";
    // 전화재시도 버튼 클릭시 이동
    string MOK_CALL_CSHTML = "./mok_ars_call";
}

<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>mok_ars_call</title>
    <script>
        const MOKAuthRequestJson = `@Html.Raw(ViewData["message"])`;
        const MOKAuthRequestJsonObject = JSON.parse(MOKAuthRequestJson);

        document.addEventListener("DOMContentLoaded", function () {
            if (MOKAuthRequestJsonObject.resultCode != '2000') {
                /* 오류발생시 */
                window.alert(MOKAuthRequestJsonObject.resultCode + ', ' + MOKAuthRequestJsonObject.resultMsg);
            } else {
                /* 정장작동시 */
                document.getElementById("MOKConfirmData").value = encodeURIComponent(MOKAuthRequestJson);
                document.getElementById("encryptMOKToken").value = MOKAuthRequestJsonObject.encryptMOKToken;
                document.getElementById("publicKey").value = MOKAuthRequestJsonObject.publicKey;
                document.getElementById("arsOtpNumber").value = MOKAuthRequestJsonObject.arsOtpNumber;
                document.getElementById("authNumber").innerText = MOKAuthRequestJsonObject.arsOtpNumber;
            }
        });
    </script>
</head>
<body>
    <div>인증번호 : <span id="authNumber"></span></div>

    <form action=@MOK_RESULT_CSHTML method="post">
        <input type="hidden" id="MOKConfirmData" name="MOKConfirmData" value='' />
        <input type="submit" value="검증" style="width:160px; height:30px; margin-right:5px;" />
        <a href=@MOK_GET_TOKEN_CSHTML>
            <input type="button" style="width:160px; height:30px; margin-left:5px; margin-bottom:15px;" value='취소' />
        </a>
    </form>
    <form action=@MOK_CALL_CSHTML method="post">
        <input type="hidden" id="encryptMOKToken" name="encryptMOKToken" value='' />
        <input type="hidden" id="arsOtpNumber" name="arsOtpNumber" value='' />
        <input type="hidden" id="publicKey" name="publicKey" value='' />
        <input type="submit" value="전화 재시도" style="width:160px; height:30px; margin-right:5px;" />
    </form>

</body>
</html>

7. 본인확인-API 검증결과 요청

본인확인-API 인증요청에서 응답받은 암호화된 거래 토큰(encryptMOKToken)을 이용하여 인증결과를 수신한다.

본인확인-API 검증 결과요청의 결과값으로 개인정보수신을 위한 MOKToken 정보 또는 개인정보가 포함된 MOKResult 데이터를 수신할 수 있다.

  • 본인확인-API 검증 결과요청 정보

    • URL

      • 운영 : https://cert-dir.mobile-ok.com/agent/v1/confirm/request

      • 개발 : https://scert-dir.mobile-ok.com/agent/v1/confirm/request

    • HTTPS 암호화 통신 : TLS 1.2 이상

    • HTTP 메소드 : POST

    • Charset : utf-8

  • 휴대폰본인확인 결과요청 원문 MOKVerifyInfo 생성

    속성 값 필수여부
    authNumber 휴대폰본인확인 서비스 인증번호 및 점유인증 인증정보
    - 본인확인 SMS/LMS 인증번호 : SMS/LMS 문자로 전달받은 6자리 인증번호
    - 본인확인 ARS 점유인증 : 빈 문자열(“”) 지정
    - ARS 소유인증: ARS 전화로 전달받은 인증번호
    - SMS 소유인증: SMS 문자로 전달받은 인증번호
    - 기타 : 웹화면 등에서 전달받은 인증번호    		 ●

  • 본인확인 인증결과 요청 JSON

    • 본인확인 인증결과 요청 정보

      속성 값 필수여부
      encryptMOKToken 본인확인-API 인증요청 또는 ARS전화요청 후 수신받은 암호화된 토큰 ●
      encryptMOKVerifyInfo 암호화된 휴대폰본인확인 MOKVerifyInfo 인증정보

    • 본인확인 인증결과 요청 JSON 예시

      {
    "encryptMOKToken" : "[hzOoAv60ZlzuAf1km9o8i8wlJo8x2uvBwTlFNItwaCF0EKK2PvHqv+yivqUqvU1d/ShmMyW0vEKG8hw9TlubnN+Tkg...3I5VTJexA8nIsVPa8UCH1kmK8rQ0zX99YgHhzC7wCoGeOEcrENGYGYVUrV/wp2J8lg8KbfCUev/+bDhowIPsa",
    "encryptMOKVerifyInfo" : "hCsUTbLCBctq1L79TZ9NgCgnM/odFM61844WdqLVQ+....NDfGSTvydrQwtyOjV2f1rEXyDCzgMIurS/ab+QGMmYMXdHvXw==|GJHVw4i9e36dOfkIfIm0EM1ep+J5NgEYF2qrPbSKscE="
}

  • 본인확인 인증결과 응답 JSON

    • 본인확인 인증결과 JSON 설명

      속성 값 필수여부
      resultCode 응답 결과 코드
      -2000일 경우 성공
      -2000이 아닐 경우 에러처리      		 ●
      resultMsg resultCode 가 2000이 아닐 경우 에러 메시지 ●
      encryptMOKResult 검증결과 요청타입이 MOKResult 일때 응답값으로 암호화된 본인확인 인증결과 데이터(본인확인-API 표준응답) ●
      retryCount 검증결과 요청 재 시도 가능횟수, 1번 잘못된 인증결과 시도 후 2 (남은 재시도 횟수) 응답

    • MOKResult 본인확인 인증결과 응답 JSON 예시

      {
    "resultCode" : "2000",
    "resultMsg" : "success",
    "encryptMOKResult" : "l8p7EtV3tHvjlGQhTpQx5IzV8H4taYxxA85lMo.../0ppE/BRBwcBneMfUXSM6hZDZf3BQ09MQU2wOoscIQ7Eu427FIg==|RiacjZlb5QdSU79goUjN0vd71u93qVr1sN7dln...rbsSxE0vDaIhEPL7vuJxbHxEmEDm0cQk0a9pZ4eWD8nFtVm/cbKnV/g=="
}

  • 본인확인 MOKResult 복호화

    이용기관에서 수신한 개인정보에 대한 검증 처리 안내

    • 이용기관에서 사전에 수집한 개인정보가 있는 경우, 본인확인을 통해 수신 후 복호화한 개인정보와 반드시 일치 여부를 검증하여야 함

  • 본인확인 MOKResult JSON 설명

    ID 내용
    siteId 이용기관 사이트 ID
    clientTxId 이용기관이 발급한 거래 ID
    txId 본인확인 서버가 발급한 거래 ID
    serviceType 본인확인 요청 서비스 타입
    providerId 이동통신사 인증시 : “SKT”, “KT”, “LGU”, “SKTMVNO”, “KTMVNO”, “LGUMVNO”
    ARS 인증: “ARS”
    SMS 소유인증: “SMS”
    ci CI (Connecting Information, 연계정보, 서비스 연계를 위해 본인확인기관에서 부여하는 개인식별정보)
    di DI (duplication information, 중복가입 확인정보, 이용기관별 개인 식별 중복 확인 정보)
    userName 사용자 이름
    userPhone 사용자 전화번호
    userBirthday 사용자 생년월일
    userGender 사용자 성별
    - “1” : 남자
    - “2”: 여자
    userNation 사용자 내외국인 정보
    - “0” : 내국인
    - “1”: 외국인
    reqdate 본인확인 거래요청시간
    issuer 본인확인 처리 서버 ID
    issueDate 발급일 (yyyy-mm-dd hh:mm:ss.mis)
    extension 이용기관별 추가정보 전달처리시 이용 데이터 JSON Object
    isAdult 성인여부
    - “Y” : 성인
    - “N”: 미성년자

    성인인증 검증결과 처리 안내

    • SMS 성인인증 요청 경우 isAdult 로 응답 값 존재.
      usageCode : 01016 (민법 기준으로 성인여부 판단), 01026 (청소년보호법 기준으로 성인여부 판단)

  • extension JSON Object 설명

    ID 내용
    recordFileName (ARS인증 중 녹취 서비스를 이용하는 경우) 사용하게 될 고유한 녹취파일 명

  • ARS 결과 복호화 예시

    {
    "siteId" : "CPID0001",
    "clientTxId" : "MOK221209170943157761", 
    "txId" : "f0aea999-2a69-4fc6-b02b-acda6f2993ff",
    "providerId" : "SKT",
    "serviceType" : "telcoAuth",
    "ci" : "lJG65/ma30qVmWY0/....591olSaU3HnDn3MT9czsKmoA==", 
    "di" : "MC0GCCq.....RMBkvnuajLHk=", 
    "userName" : "홍길동", 
    "userPhone" : "01012345678",
    "userBirthday" : "20000101", 
    "userGender" : "1", 
    "userNation" : "0", 
    "reqdate" : "221209170943",
    "issuer" : "MobileOK Agent1", 
    "issueDate" : "2022-12-12 13:34:12.234"
}

    {
    "siteId" : "CPID0001",
    "clientTxId" : "MOK221209170943157761", 
    "txId" : "f0aea999-2a69-4fc6-b02b-acda6f2993ff",
    "providerId" : "SKT",
    "serviceType" : "telcoAuth",
    "ci" : "lJG65/ma30qVmWY0/....591olSaU3HnDn3MT9czsKmoA==", 
    "di" : "MC0GCCq.....RMBkvnuajLHk=", 
    "userName" : "홍길동", 
    "userPhone" : "01012345678",
    "userBirthday" : "20000101", 
    "userGender" : "1", 
    "userNation" : "0", 
    "reqdate" : "221209170943",
    "issuer" : "MobileOK Agent1", 
    "issueDate" : "2022-12-12 13:34:12.234",
    "extension":{"arsResultMsg":"{\"companyName\":\"이용기관명\"}"}
}


  • 본인확인 인증결과 API 요청 및 응답 예제

    mok_api_result.jsp
      1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
    <%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<%@ page import="java.io.*" %>
<%@ page import="java.util.Date"%>
<%@ page import="java.text.SimpleDateFormat"%>
<%@ page import="java.net.HttpURLConnection" %>
<%@ page import="java.net.URL" %>
<%@ page import="java.net.URLEncoder" %>
<%@ page import="java.net.URLDecoder" %>
<%@ page import="com.dreamsecurity.json.JSONObject" %>
<%@ page import="com.dreamsecurity.mobileOK.mobileOKKeyManager" %>
<%@ page import="com.dreamsecurity.mobileOK.MobileOKException" %>

<%!
    /* 1. 본인확인 인증결과 MOKConfirm API 또는 MOKResult API 요청 URL */
    //private final String MOK_CONFIRM_URL = "https://cert-dir.mobile-ok.com/agent/v1/confirm/request";  // 운영
    private final String MOK_CONFIRM_URL = "https://scert-dir.mobile-ok.com/agent/v1/confirm/request"; // 개발

    /* 재시도 버튼 클릭시 이동 JSP (mobileOK-Request JSP)*/
    private final String MOK_REQUEST_JSP = "./mok_api_request.jsp";

    /* 처음페이지 버튼 클릭시 이동 JSP (mobileOK-GetToken JSP)*/
    private final String MOK_GET_TOKEN_JSP = "./mok_api_gettoken.jsp";

%>

<%
    /* 2. 본인확인 서비스 API 초기화 */
    mobileOKKeyManager mobileOK = null;
    String MOKResult = "";

    try {
        mobileOK = new mobileOKKeyManager();
        /* 키파일은 반드시 서버의 안전한 로컬경로에 별도 저장. 웹URL 경로에 파일이 있을경우 키파일이 외부에 노출될 수 있음 주의 */
        mobileOK.keyInit("/본인확인-API 키정보파일 Path/mok_keyInfo.dat", "키파일 패스워드");

        String MOKConfirmData = request.getParameter("MOKConfirmData");
        if (MOKConfirmData == null || MOKConfirmData.equals("")) {
            throw new MobileOKException("-1|본인확인 요청 MOKToken이 없습니다.");
        }

        MOKConfirmData = URLDecoder.decode(MOKConfirmData, "UTF-8");
        MOKResult = mobileOK_api_result(MOKConfirmData, mobileOK, session, request);
    } catch (MobileOKException e) {
        MOKResult = setErrorMsg(e.getMessage());
    } catch (Exception e) {
        e.printStackTrace();
    }
%>

<%!
    /* 본인확인 API 검증요청 예제 함수 */
    public String mobileOK_api_result(String MOKConfirmData, mobileOKKeyManager mobileOK, HttpSession session, HttpServletRequest request) throws MobileOKException {
        try {
            /* 3. 본인확인 검증요청 입력정보 설정 (아래 MOKConfirmRequestToJsonString() 참조) */
            JSONObject MOKConfrimRequestData = new JSONObject(MOKConfirmData);
            String MOKConfrimRequest = "";

            String encMOKToken = MOKConfrimRequestData.optString("encryptMOKToken", null);

            if (encMOKToken == null) {
                return setErrorMsg("-1|본인확인 요청 MOKToken이 없습니다.");
            }

            if (null != request.getParameter("authNumber")
                    && !"".equals(request.getParameter("authNumber").trim())) {
                MOKConfrimRequest = MOKConfirmRequestToJsonString(
                    mobileOK
                    , MOKConfrimRequestData.getString("encryptMOKToken") /* MOK_API_AUTH_REQUEST에서 발급 받은 encryptMOKToken */
                    , MOKConfrimRequestData.getString("publicKey")       /* MOK_API_GET_TOKEN에서 발급 받은 publicKey */
                    , request.getParameter("authNumber")                 /* 본인확인 인증요청으로 수신한 인증번호(authNumber)" */
                );
            } else {
                MOKConfrimRequest = MOKConfirmRequestToJsonString(
                    mobileOK
                    , MOKConfrimRequestData.getString("encryptMOKToken") /* MOK_API_AUTH_REQUEST에서 발급 받은 encryptMOKToken */
                    , MOKConfrimRequestData.getString("publicKey")       /* MOK_API_GET_TOKEN에서 발급 받은 publicKey */
                    , ""                                                 /* 본인확인 인증요청으로 수신한 인증번호(authNumber)" */
                );
            }

            /* 4. 본인확인 인증결과 확인 요청 */
            String MOKConfirmResponse = sendPost(MOK_CONFIRM_URL, MOKConfrimRequest);

            /* 5. 본인확인 결과 JSON 정보 반환 */
            JSONObject decrpytResultJson = null;
            try {
                JSONObject MOKConfirmResponseJson = new JSONObject(MOKConfirmResponse);

                if (!"2000".equals(MOKConfirmResponseJson.getString("resultCode"))) {
                    String encryptMOKToken = MOKConfirmResponseJson.optString("encryptMOKToken", null);
                    if (encryptMOKToken != null) {
                        try{
                            encryptMOKToken = URLEncoder.encode(encryptMOKToken, "UTF-8");
                        } catch (UnsupportedEncodingException e) {
                            return setErrorMsg("URLEncoding에 실패했습니다.");
                        }

                        JSONObject retryDataJson = new JSONObject();
                        retryDataJson.put("publicKey", MOKConfrimRequestData.getString("publicKey"));     /* MOK_API_GET_TOKEN에서 발급 받은 publicKey */
                        retryDataJson.put("encryptMOKToken", encryptMOKToken);                            /* MOK_API_CONFIRM에서 발급 받은 encryptMOKToken */
                        retryDataJson.put("resultCode", MOKConfirmResponseJson.getString("resultCode"));  /* MOK_API_CONFIRM에서 발급 받은 resultCode */
                        retryDataJson.put("resultMsg", MOKConfirmResponseJson.getString("resultMsg"));    /* MOK_API_CONFIRM에서 발급 받은 resultMsg */

                        return retryDataJson.toString();
                    } else {
                        return MOKConfirmResponse;
                    }
                }

                /* 5.1. 본인확인 인증결과 응답 암호화데이터 복호화 */
                String encryptMOKResult = MOKConfirmResponseJson.getString("encryptMOKResult");
                decrpytResultJson = new JSONObject(mobileOK.getResultJSON(encryptMOKResult));
            } catch (MobileOKException e) {
                return setErrorMsg(e.getMessage());
            }

            /* 6. 본인확인 인증결과 반환데이터 설정 */

            /* 이용기관 거래 ID */
            String clientTxId = decrpytResultJson.optString("clientTxId", null);

            String sessionClientTxId = (String) session.getAttribute("sessionClientTxId");
            // 세션 내 요청 clientTxId 와 수신한 clientTxId 가 동일한지 반드시 비교
            if (!sessionClientTxId.equals(clientTxId)) {
                return setErrorMsg("-4|세션값에 저장된 거래ID 비교 실패");
            }

            /* 사용자 이름 */
            String userName = decrpytResultJson.optString("userName", null);
            /* 이용기관 ID */
            String siteId = decrpytResultJson.optString("siteId", null);
            /* 본인확인 거래 ID */
            String txId = decrpytResultJson.optString("txId", null);
            /* 서비스제공자(인증사업자) ID */
            String providerId = decrpytResultJson.optString("providerId", null);
            /* 이용 서비스 유형 */
            String serviceType = decrpytResultJson.optString("serviceType", null);
            /* 사용자 CI */
            String ci = decrpytResultJson.optString("ci", null);
            /* 사용자 DI */
            String di = decrpytResultJson.optString("di", null);
            /* 사용자 전화번호 */
            String userPhone = decrpytResultJson.optString("userPhone", null);
            /* 사용자 생년월일 */
            String userBirthday = decrpytResultJson.optString("userBirthday", null);
            /* 사용자 성별 (1: 남자, 2: 여자) */
            String userGender = decrpytResultJson.optString("userGender", null);
            /* 사용자 국적 (0: 내국인, 1: 외국인) */
            String userNation = decrpytResultJson.optString("userNation", null);
            /* 성인 인증 결과 (Y: 성인, N: 미성년자) SMS 성인여부 요청 시 응답 값이 존재*/
            String isAdult = decrpytResultJson.optString("isAdult", null);
            /* 본인확인 인증 종류 */
            String reqAuthType = decrpytResultJson.getString("reqAuthType");
            /* 본인확인 요청 시간 */
            String reqDate = decrpytResultJson.getString("reqDate");
            /* 본인확인 인증 서버 */
            String issuer = decrpytResultJson.getString("issuer");
            /* 본인확인 인증 시간 */
            String issueDate = decrpytResultJson.getString("issueDate");

            /* 7. 이용기관 응답데이터 셔션 및 검증유효시간 처리 */

            // 검증정보 유효시간 검증 (검증결과 생성 후 10분 이내 검증 권고) 
            String dataFormat = "yyyy-MM-dd HH:mm:ss";
            SimpleDateFormat formatter = new SimpleDateFormat(dataFormat);

            Date currentTime = formatter.parse(formatter.format(new Date()));
            Date targetTime = formatter.parse(issueDate);

            long diff = (currentTime.getTime() - targetTime.getTime()) / 1000;

            if (diff > 600) {
                return setErrorMsg("-5|검증결과 토큰 생성 10분 경과 오류");
            }

            /* 8. 이용기관 서비스 기능 처리 */

            // - 이용기관에서 수신한 개인정보 검증 확인 처리

            // - 이용기관에서 수신한 CI 확인 처리

            /* 9. 본인확인 결과 응답 */

            // 복호화된 개인정보는 DB보관 또는 세션보관하여 개인정보 저장시 본인확인에서 획득한 정보로 저장하도록 처리 필요
            // 개인정보를 웹브라우져에 전달할 경우 외부 해킹에 의해 유출되지 않도록 보안처리 필요

            JSONObject resultJson = new JSONObject();
            resultJson.put("resultCode", "2000");
            resultJson.put("resultMsg", "성공");
            resultJson.put("userName", userName);

            return resultJson.toString();
        } catch (Exception e) {
            e.printStackTrace();
            return "-999|서버 오류";
        }
    }

    /* 본인확인-API 검증요청 정보 */
    public String MOKConfirmRequestToJsonString(
            mobileOKKeyManager mobileOK
            , String encryptMOKToken
            , String publicKey
            , String authNumber
        ) throws MobileOKException {

        JSONObject MOKconfirmRequestJson = new JSONObject();
        MOKconfirmRequestJson.put("encryptMOKToken", encryptMOKToken);

        if (null != authNumber
                && !"".equals(authNumber)) {
            JSONObject authNumberJson = new JSONObject();
            authNumberJson.put("authNumber", authNumber);

            String encAuthNumber = mobileOK.RSAServerEncrypt(publicKey, authNumberJson.toString());

            MOKconfirmRequestJson.put("encryptMOKVerifyInfo", encAuthNumber);
        } 

        return MOKconfirmRequestJson.toString();
    }

    /* 본인확인 서버 통신 예제 함수 */
    public String sendPost(String dest, String jsonData) throws MobileOKException {
        HttpURLConnection connection = null;
        DataOutputStream dataOutputStream = null;
        BufferedReader bufferedReader = null;

        try {
            URL url = new URL(dest);
            connection = (HttpURLConnection) url.openConnection();
            connection.setRequestMethod("POST");
            connection.setRequestProperty("Content-Type", "application/json;charset=UTF-8");
            connection.setDoOutput(true);

            dataOutputStream = new DataOutputStream(connection.getOutputStream());
            dataOutputStream.write(jsonData.getBytes("UTF-8"));

            bufferedReader = new BufferedReader(new InputStreamReader(connection.getInputStream()));
            StringBuffer responseData = new StringBuffer();
            String info;
            while ((info = bufferedReader.readLine()) != null) {
                responseData.append(info);
            }
            return responseData.toString();
        } catch (FileNotFoundException e) {
            throw new MobileOKException("-5|MOK_CONFIRM_URL을 확인해주세요.");
        } catch (IOException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (bufferedReader != null) {
                    bufferedReader.close();
                }

                if (dataOutputStream != null) {
                    dataOutputStream.close();
                }

                if (connection != null) {
                    connection.disconnect();
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return null;
    }

    private String setErrorMsg(String errorMsg) {
        JSONObject errorJson = new JSONObject();
        errorJson.put("resultMsg", errorMsg);
        return errorJson.toString();
    }
%>

<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>mok_api_result</title>
    <script>
        let MOKResultJson = decodeURIComponent('<%= MOKResult %>');
        MOKResultJson = JSON.parse(MOKResultJson);

        if (MOKResultJson.resultCode != '2000') {
            /* 오류발생시 */
            window.alert(MOKResultJson.resultCode + ', ' + MOKResultJson.resultMsg);
        } else {
            /* 정상작동시 */
            document.addEventListener("DOMContentLoaded", function () {
                document.getElementById("MOKResultJsonString").innerText = JSON.stringify(MOKResultJson);
            });
        }
    </script>
</head>
<body>
    <p id='MOKResultJsonString'>
    </p>
    <br>
    <form action='<%= MOK_REQUEST_JSP %>' method="post">
        <input type="hidden" id="MOKConfirmRetryData" name="MOKConfirmRetryData" value='<%= MOKResult %>' />
        <input type="submit" style="width:160px; height:30px; margin-left:5px; margin-bottom:15px;" value='검증 재시도' />
        <a href='<%= MOK_GET_TOKEN_JSP %>'> 
        <input type="button" style="width:160px; height:30px; margin-left:5px; margin-bottom:15px;" value='처음페이지' />
        </a>
    </form>
</body>
</html>
    mok_api_result.jsp
      1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
    <%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<%@ page import="java.io.*" %>
<%@ page import="java.net.URL" %>
<%@ page import="java.net.URLEncoder" %>
<%@ page import="java.net.URLDecoder" %>
<%@ page import="java.util.Date"%>
<%@ page import="java.text.SimpleDateFormat"%>
<%@ page import="com.dreamsecurity.json.JSONObject" %>
<%@ page import="com.dreamsecurity.mobileOK.mobileOKKeyManager" %>
<%@ page import="com.dreamsecurity.mobileOK.MobileOKException" %>
<%@ page import="javax.net.ssl.SSLContext"%>
<%@ page import="java.security.Security"%>
<%@ page import="java.security.SecureRandom"%>
<%@ page import="org.bouncycastle.jce.provider.BouncyCastleProvider"%>
<%@ page import="org.bouncycastle.jsse.provider.BouncyCastleJsseProvider"%>
<%@ page import="javax.net.ssl.HttpsURLConnection"%>

<%!
/* 1. 본인확인 인증결과 MOKConfirm API 또는 MOKResult API 요청 URL */
//private final String MOK_CONFIRM_URL = "https://cert-dir.mobile-ok.com/agent/v1/confirm/request";  // 운영
private final String MOK_CONFIRM_URL = "https://scert-dir.mobile-ok.com/agent/v1/confirm/request"; // 개발

    /* 재시도 버튼 클릭시 이동 JSP (mobileOK-Request JSP)*/
    private final String MOK_REQUEST_JSP = "./mok_api_request.jsp";

    /* 처음페이지 버튼 클릭시 이동 JSP (mobileOK-GetToken JSP)*/
    private final String MOK_GET_TOKEN_JSP = "./mok_api_gettoken.jsp";
%>

<%

    if (Security.getProvider(BouncyCastleProvider.PROVIDER_NAME) == null) {
        Security.addProvider(new BouncyCastleProvider());
        Security.addProvider(new BouncyCastleJsseProvider());
        System.setProperty("jdk.tls.trustNameService", "true");
    }

    /* 2. 본인확인 서비스함수 API 설정 */
    mobileOKKeyManager mobileOK = null;
    String MOKResult = "";
    try {
        mobileOK = new mobileOKKeyManager();
        /* 키파일은 반드시 서버의 안전한 로컬경로에 별도 저장. 웹URL 경로에 파일이 있을경우 키파일이 외부에 노출될 수 있음 주의 */
        mobileOK.keyInit("/본인확인-API 키정보파일 Path/mok_keyInfo.dat", "키파일 패스워드");

        String MOKConfirmData = request.getParameter("MOKConfirmData");
        if (MOKConfirmData == null || MOKConfirmData.equals("")) {
            throw new MobileOKException("-1|본인확인 요청 MOKToken이 없습니다.");
        }

        MOKConfirmData = URLDecoder.decode(MOKConfirmData, "UTF-8");
        MOKResult = mobileOK_api_result(MOKConfirmData, mobileOK, session, request);
    } catch (MobileOKException e) {
        MOKResult = setErrorMsg(e.getMessage());
    } catch (Exception e) {
        e.printStackTrace();
    }
%>

<%!
    /* 본인확인 API 검증요청 예제 함수 */
    public String mobileOK_api_result(String MOKConfirmData, mobileOKKeyManager mobileOK, HttpSession session, HttpServletRequest request) throws MobileOKException {
        try {
            /* 3. 본인확인 검증요청 입력정보 설정 (아래 MOKConfirmRequestToJsonString() 참조) */
            JSONObject MOKConfrimRequestData = new JSONObject(MOKConfirmData);
            String encMOKToken = MOKConfrimRequestData.optString("encryptMOKToken", null);
            if (encMOKToken == null) {
                return setErrorMsg("-1|본인확인 요청 MOKToken이 없습니다.");
            }

            String MOKConfrimRequest = "";
            if (null != request.getParameter("authNumber")
                    && !"".equals(request.getParameter("authNumber").trim())) {
                MOKConfrimRequest = MOKConfirmRequestToJsonString(
                    mobileOK
                    , MOKConfrimRequestData.getString("encryptMOKToken") /* MOK_API_AUTH_REQUEST에서 발급 받은 encryptMOKToken */
                    , MOKConfrimRequestData.getString("publicKey")       /* MOK_API_GET_TOKEN에서 발급 받은 publicKey */
                    , request.getParameter("authNumber")                 /* 본인확인 인증요청으로 수신한 인증번호(authNumber)" */
                );
            } else {
                MOKConfrimRequest = MOKConfirmRequestToJsonString(
                    mobileOK
                    , MOKConfrimRequestData.getString("encryptMOKToken") /* MOK_API_AUTH_REQUEST에서 발급 받은 encryptMOKToken */
                    , MOKConfrimRequestData.getString("publicKey")       /* MOK_API_GET_TOKEN에서 발급 받은 publicKey */
                    , ""                                                 /* 본인확인 인증요청으로 수신한 인증번호(authNumber)" */
                );
            }

            /* 4. 본인확인 인증결과 확인 요청 */
            String MOKConfirmResponse = sendPost(MOK_CONFIRM_URL, MOKConfrimRequest);

            /* 5. 본인확인 결과 JSON 정보 반환 */
            JSONObject decrpytResultJson = null;
            try {
                JSONObject MOKConfirmResponseJson = new JSONObject(MOKConfirmResponse);

                if (!"2000".equals(MOKConfirmResponseJson.getString("resultCode"))) {
                    String encryptMOKToken = MOKConfirmResponseJson.optString("encryptMOKToken", null);
                    if (encryptMOKToken != null) {
                        try{
                            encryptMOKToken = URLEncoder.encode(encryptMOKToken, "UTF-8");
                        } catch (UnsupportedEncodingException e) {
                            return setErrorMsg("URLEncoding에 실패했습니다.");
                        }

                        JSONObject retryDataJson = new JSONObject();
                        retryDataJson.put("publicKey", MOKConfrimRequestData.getString("publicKey"));     /* MOK_API_GET_TOKEN에서 발급 받은 publicKey */
                        retryDataJson.put("encryptMOKToken", encryptMOKToken);                            /* MOK_API_CONFIRM에서 발급 받은 encryptMOKToken */
                        retryDataJson.put("resultCode", MOKConfirmResponseJson.getString("resultCode"));  /* MOK_API_CONFIRM에서 발급 받은 resultCode */
                        retryDataJson.put("resultMsg", MOKConfirmResponseJson.getString("resultMsg"));    /* MOK_API_CONFIRM에서 발급 받은 resultMsg */

                        return retryDataJson.toString();
                    } else {
                        return MOKConfirmResponse;
                    }
                }

                /* 5.1. 본인확인 인증결과 응답 암호화데이터 복호화 */
                String encryptMOKResult = MOKConfirmResponseJson.getString("encryptMOKResult");
                decrpytResultJson = new JSONObject(mobileOK.getResultJSON(encryptMOKResult));
            } catch (MobileOKException e) {
                return setErrorMsg(e.getMessage());
            }

            /* 6. 본인확인 인증결과 반환데이터 설정 */

            /* 이용기관 거래 ID */
            String clientTxId = decrpytResultJson.optString("clientTxId", null);

            String sessionClientTxId = (String) session.getAttribute("sessionClientTxId");
            // 세션 내 요청 clientTxId 와 수신한 clientTxId 가 동일한지 반드시 비교
            if (!sessionClientTxId.equals(clientTxId)) {
                return setErrorMsg("-4|세션값에 저장된 거래ID 비교 실패");
            }

            /* 사용자 이름 */
            String userName = decrpytResultJson.optString("userName", null);
            /* 이용기관 ID */
            String siteId = decrpytResultJson.optString("siteId", null);
            /* 본인확인 거래 ID */
            String txId = decrpytResultJson.optString("txId", null);
            /* 서비스제공자(인증사업자) ID */
            String providerId = decrpytResultJson.optString("providerId", null);
            /* 이용 서비스 유형 */
            String serviceType = decrpytResultJson.optString("serviceType", null);
            /* 사용자 CI */
            String ci = decrpytResultJson.optString("ci", null);
            /* 사용자 DI */
            String di = decrpytResultJson.optString("di", null);
            /* 사용자 전화번호 */
            String userPhone = decrpytResultJson.optString("userPhone", null);
            /* 사용자 생년월일 */
            String userBirthday = decrpytResultJson.optString("userBirthday", null);
            /* 사용자 성별 (1: 남자, 2: 여자) */
            String userGender = decrpytResultJson.optString("userGender", null);
            /* 사용자 국적 (0: 내국인, 1: 외국인) */
            String userNation = decrpytResultJson.optString("userNation", null);
            /* 성인 인증 결과 (Y: 성인, N: 미성년자) SMS 성인여부 요청 시 응답 값이 존재*/
            String isAdult = decrpytResultJson.optString("isAdult", null);
            /* 본인확인 인증 종류 */
            String reqAuthType = decrpytResultJson.getString("reqAuthType");
            /* 본인확인 요청 시간 */
            String reqDate = decrpytResultJson.getString("reqDate");
            /* 본인확인 인증 서버 */
            String issuer = decrpytResultJson.getString("issuer");
            /* 본인확인 인증 시간 */
            String issueDate = decrpytResultJson.getString("issueDate");

            /* 7. 이용기관 응답데이터 셔션 및 검증유효시간 처리 */

            // 검증정보 유효시간 검증 (검증결과 생성 후 10분 이내 검증 권고)
            String dataFormat = "yyyy-MM-dd HH:mm:ss";
            SimpleDateFormat formatter = new SimpleDateFormat(dataFormat);

            Date currentTime = formatter.parse(formatter.format(new Date()));
            Date targetTime = formatter.parse(issueDate);

            long diff = (currentTime.getTime() - targetTime.getTime()) / 1000;

            if (diff > 600) {
                return setErrorMsg("-5|검증결과 토큰 생성 10분 경과 오류");
            }

            /* 8. 이용기관 서비스 기능 처리 */

            // - 이용기관에서 수신한 개인정보 검증 확인 처리

            // - 이용기관에서 수신한 CI 확인 처리

            /* 9. 본인확인 결과 응답 */

            // 복호화된 개인정보는 DB보관 또는 세션보관하여 개인정보 저장시 본인확인에서 획득한 정보로 저장하도록 처리 필요
            // 개인정보를 웹브라우져에 전달할 경우 외부 해킹에 의해 유출되지 않도록 보안처리 필요

            JSONObject resultJson = new JSONObject();
            resultJson.put("resultCode", "2000");
            resultJson.put("resultMsg", "성공");
            resultJson.put("userName", userName);

            return resultJson.toString();
        } catch (Exception e) {
            e.printStackTrace();
            return "-999|서버 오류";
        }
    }

    /* 본인확인-API 검증요청 정보 */
    public String MOKConfirmRequestToJsonString(
            mobileOKKeyManager mobileOK
            , String encryptMOKToken
            , String publicKey
            , String authNumber
        ) throws MobileOKException {

        JSONObject MOKconfirmRequestJson = new JSONObject();
        MOKconfirmRequestJson.put("encryptMOKToken", encryptMOKToken);

        if (null != authNumber
                && !"".equals(authNumber)) {
            JSONObject authNumberJson = new JSONObject();
            authNumberJson.put("authNumber", authNumber);

            String encAuthNumber = mobileOK.RSAServerEncrypt(publicKey, authNumberJson.toString());

            MOKconfirmRequestJson.put("encryptMOKVerifyInfo", encAuthNumber);
        } 

        return MOKconfirmRequestJson.toString();
    }

    /* 본인확인 서버 통신 예제 함수 */
    public String sendPost(String dest, String jsonData) throws MobileOKException {
        HttpsURLConnection connection = null;
        DataOutputStream dataOutputStream = null;
        BufferedReader bufferedReader = null;

        try {
            SSLContext sslContext = SSLContext.getInstance("TLSv1.2", new BouncyCastleJsseProvider());
            sslContext.init(null, null, new SecureRandom());

            URL url = new URL(dest);
            connection = (HttpsURLConnection) url.openConnection();
            connection.setSSLSocketFactory(sslContext.getSocketFactory());

            connection.setRequestMethod("POST");
            connection.setRequestProperty("Content-Type", "application/json;charset=UTF-8");
            connection.setDoOutput(true);

            dataOutputStream = new DataOutputStream(connection.getOutputStream());
            dataOutputStream.write(jsonData.getBytes("UTF-8"));

            bufferedReader = new BufferedReader(new InputStreamReader(connection.getInputStream()));
            StringBuffer responseData = new StringBuffer();
            String info;
            while ((info = bufferedReader.readLine()) != null) {
                responseData.append(info);
            }
            return responseData.toString();
        } catch (FileNotFoundException e) {
            throw new MobileOKException("-5|MOK_CONFIRM_URL을 확인해주세요.");
        } catch (IOException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (bufferedReader != null) {
                    bufferedReader.close();
                }

                if (dataOutputStream != null) {
                    dataOutputStream.close();
                }

                if (connection != null) {
                    connection.disconnect();
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return null;
    }

    private String setErrorMsg(String errorMsg) {
        JSONObject errorJson = new JSONObject();
        errorJson.put("resultMsg", errorMsg);

        return errorJson.toString();
    }
%>

<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>mok_api_result</title>
    <script>
        let MOKResultJson = decodeURIComponent('<%= MOKResult %>');
        MOKResultJson = JSON.parse(MOKResultJson);
        if (MOKResultJson.resultCode != '2000') {
            /* 오류발생시 */
            window.alert(MOKResultJson.resultCode + ', ' + MOKResultJson.resultMsg);
        } else {
            /* 정상작동시 */
            document.addEventListener("DOMContentLoaded", function () {
                document.getElementById("MOKResultJsonString").innerText = JSON.stringify(MOKResultJson);
            });
        }
    </script>
</head>
<body>
    <p id='MOKResultJsonString'>
    </p>
    <br>
    <form action='<%= MOK_REQUEST_JSP %>' method="post">
        <input type="hidden" id="MOKConfirmRetryData" name="MOKConfirmRetryData" value='<%= MOKResult %>' />
            <input type="submit" style="width:160px; height:30px; margin-left:5px; margin-bottom:15px;" value='검증 재시도' />
            <a href='<%= MOK_GET_TOKEN_JSP %>'> 
            <input type="button" style="width:160px; height:30px; margin-left:5px; margin-bottom:15px;" value='처음페이지' />
        </a>
    </form>
</body>
</html>
    mok_api_result.php
      1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
    <?php
    // 각 버전 별 맞는 mobileOKManager-php를 사용
    $mobileOK_path = "./mobileOK_manager_phpseclib_v3.0_v1.0.2.php";

    if(!file_exists($mobileOK_path)) {
        die('1000|mobileOK_Key_Manager파일이 존재하지 않습니다.');
    } else {
        require_once $mobileOK_path;
    }
?>
<?php
    // local시간 설정이 다르게 될  수 있음으로 기본 시간 설정을 서울로 해놓는다.
    date_default_timezone_set('Asia/Seoul');

    session_start();
?>
<?php
    /* 1. 본인확인 인증결과 MOKConfirm API 또는 MOKResult API 요청 URL */
    $MOK_CONFIRM_URL = "https://scert-dir.mobile-ok.com/agent/v1/confirm/request";  // 개발
    // $MOK_CONFIRM_URL = "https://cert-dir.mobile-ok.com/agent/v1/confirm/request";  // 운영

    /* 처음페이지 버튼 클릭시 이동 PHP (mobileOK-GetToken PHP)*/
    $MOK_API_GET_TOKEN_PHP = "/mok_api_gettoken.php";
    /* 재시도 버튼 클릭시 이동 PHP (mobileOK-Request PHP)*/
    $MOK_API_REQUEST_PHP = "/mok_api_request.php";

    /* 2. 본인확인 서비스 API 설정 */
    $mobileOK = new mobileOK_Key_Manager();
    /* 키파일은 반드시 서버의 안전한 로컬경로에 별도 저장. 웹URL 경로에 파일이 있을경우 키파일이 외부에 노출될 수 있음 주의 */
    $key_path = "/본인확인-API 키정보파일 Path/mok_keyInfo.dat";
    $password = "키파일 패스워드";
    $mobileOK->key_init($key_path, $password);

    $MOK_RESULT = mobileOK_api_result($mobileOK, $MOK_CONFIRM_URL);
?>
<?php
    /* 본인확인 API 검증요청 예제 함수 */
    function mobileOK_api_result($mobileOK, $MOK_CONFIRM_URL) {
        /* 3. 본인확인 검증요청 입력정보 설정 (아래 MOKConfirmRequestToJsonString() 참조) */
        $MOK_confirm_data = json_decode($_POST['MOKConfirmData']);

        $encryptMOKToken = isset($MOK_confirm_data->encryptMOKToken) ? $MOK_confirm_data->encryptMOKToken : null;
        if ($encryptMOKToken == null) {
            $errorResult = array("resultMsg" => "-1|본인확인 요청 MOKToken이 없습니다.");
            return json_encode($errorResult);
        } 

        $MOK_confirm_request_json_string = '';
        if (null != $_POST['authNumber']
                && '' != $_POST['authNumber']) {
            $MOK_confirm_request_json_string = MOKConfirmRequestToJsonString(
                $mobileOK
                , $MOK_confirm_data -> encryptMOKToken /* MOK_API_AUTH_REQUEST에서 발급 받은 encryptMOKToken */
                , $MOK_confirm_data -> publicKey       /* MOK_API_GET_TOKEN에서 발급 받은 publicKey */
                , $_POST['authNumber']                 /* 본인확인 인증요청으로 수신한 인증번호(authNumber)" */
            );
        } else {
            $MOK_confirm_request_json_string = MOKConfirmRequestToJsonString(
                $mobileOK
                , $MOK_confirm_data -> encryptMOKToken /* MOK_API_AUTH_REQUEST에서 발급 받은 encryptMOKToken */
                , $MOK_confirm_data -> publicKey       /* MOK_API_GET_TOKEN에서 발급 받은 publicKey */
                , ''                                   /* 본인확인 인증요청으로 수신한 인증번호(authNumber)" */
            );
        }

        /* 4. 본인확인 인증결과 확인 요청 */
        $MOK_confirm_response_json = sendPost($MOK_confirm_request_json_string, $MOK_CONFIRM_URL);

        /* 5. 본인확인 결과 JSON 정보 복호화 */
        try {
            $MOK_confirm_response_array = json_decode($MOK_confirm_response_json);
            if ('2000' != $MOK_confirm_response_array->resultCode) {
                $MOK_confirm_retry_data = array(
                    "resultCode" => $MOK_confirm_response_array -> resultCode
                    , "resultMsg" => $MOK_confirm_response_array -> resultMsg
                    , "publicKey" => $MOK_confirm_data -> publicKey
                );

                if (isset($MOK_confirm_response_array -> encryptMOKToken)) {
                    $MOK_confirm_retry_data["encryptMOKToken"] = $MOK_confirm_response_array -> encryptMOKToken;
                }

                return json_encode($MOK_confirm_retry_data, JSON_UNESCAPED_SLASHES);
            }

            /* 5-1 본인확인 결과정보 복호화 */
            $encrypt_MOK_result = $MOK_confirm_response_array->encryptMOKResult;
            $decrypt_result_json = $mobileOK->get_result($encrypt_MOK_result);
        } catch (Exception $e) {
            return $decrypt_result_json;
        }

        /* 6. 본인확인 인증결과 반환데이터 설정 */

        /* 이용기관 거래 ID */
        $client_tx_id = isset($decrypt_result_array->clientTxId) ?$decrypt_result_array->clientTxId : null;

        // 세션 내 요청 clientTxId 와 수신한 clientTxId 가 동일한지 반드시 비교
        $session_client_tx_id = $_SESSION['sessionClientTxId'];
        if ($session_client_tx_id !== $client_tx_id){
            $errorResult = array("resultMsg" => "-4|세션값에 저장된 거래ID 비교 실패");
            return json_encode($errorResult);
        }

        /* 사용자 이름 */
        $decrypt_result_array = json_decode($decrypt_result_json);
        $user_name = isset($decrypt_result_array->userName) ? $decrypt_result_array->userName : null;
        /* 이용기관 ID */
        $site_id = isset($decrypt_result_array->siteId) ? $decrypt_result_array->siteId : null;
        /* 본인확인 거래 ID */
        $tx_id = isset($decrypt_result_array->txId) ? $decrypt_result_array->txId : null;
        /* 서비스제공자(인증사업자) ID */
        $provider_id = isset($decrypt_result_array->providerId) ? $decrypt_result_array->providerId : null;
        /* 이용 서비스 유형 */
        $service_type = isset($decrypt_result_array->serviceType) ? $decrypt_result_array->serviceType : null;
        /* 사용자 CI */
        $ci = isset($decrypt_result_array->ci) ? $decrypt_result_array->ci : null;
        /* 사용자 DI */
        $di = isset($decrypt_result_array->di) ? $decrypt_result_array->di : null;
        /* 사용자 전화번호 */
        $user_phone = isset($decrypt_result_array->userPhone) ? $decrypt_result_array->userPhone : null;
        /* 사용자 생년월일 */
        $user_birthday = isset($decrypt_result_array->userBirthday) ? $decrypt_result_array->userBirthday : null;
        /* 사용자 성별 (1: 남자, 2: 여자) */
        $user_gender = isset($decrypt_result_array->userGender) ? $decrypt_result_array->userGender : null;
        /* 사용자 국적 (0: 내국인, 1: 외국인) */
        $user_nation = isset($decrypt_result_array->userNation) ? $decrypt_result_array->userNation : null;
        /* 성인 인증 결과 (Y: 성인, N: 미성년자) SMS 성인여부 요청 시 응답 값이 존재*/
        $isAdult = isset($decrypt_result_array->isAdult) ? $decrypt_result_array->isAdult : null;
        /* 본인확인 인증 종류 */
        $req_auth_type = $decrypt_result_array->reqAuthType;
        /* 본인확인 요청 시간 */
        $req_date = $decrypt_result_array->reqDate;
        /* 본인확인 인증 서버 */
        $issuer = $decrypt_result_array->issuer;
        /* 본인확인 인증 시간 */
        $issue_date = $decrypt_result_array->issueDate;

        /* 7. 이용기관 응답데이터 셔션 및 검증유효시간 처리  */

        // 검증정보 유효시간 검증 (토큰 생성 후 10분 이내 검증 권고)
        $date_time = date("Y-m-d H:i:s");

        $old = strtotime($issue_date);
        $old = date("Y-m-d H:i:s", $old);

        $time_limit = strtotime($old."+10 minutes");
        $time_limit = date("Y-m-d H:i:s", $time_limit);

        if ($time_limit < $date_time) {
            $errorResult = array("resultMsg" => "-5|토큰 생성 10분 경과");
            return '';
        }

        /* 8. 이용기관 서비스 기능 처리 */

        // - 이용기관에서 수신한 개인정보 검증 확인 처리

        // - 이용기관에서 수신한 CI 확인 처리


        /* 9. 본인확인 결과 응답 */

        // 복호화된 개인정보는 DB보관 또는 세션보관하여 개인정보 저장시 본인확인에서 획득한 정보로 저장하도록 처리 필요

        $result_array = array(
            "resultCode" => "2000"
            , "resultMsg" => "성공"
            , "userName" => $user_name
        );
        $result_json = json_encode($result_array, JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES);

        return $result_json;
    }

    /* 본인확인-API 검증요청 정보 */
    function MOKConfirmRequestToJsonString($mobileOK, $encrypt_MOK_token, $public_key, $auth_number) {
        $confirm_request_array = array(
            'encryptMOKToken'=> $encrypt_MOK_token
        );

        if (null != $auth_number
                && '' != $auth_number) {
            $auth_number_array = array(
                'authNumber' => $auth_number
            );
            $auth_number_json = json_encode($auth_number_array, JSON_UNESCAPED_SLASHES);

            $enc_auth_number = $mobileOK->rsa_public_encrypt($public_key, $auth_number_json);

            $confirm_request_array['encryptMOKVerifyInfo'] = $enc_auth_number;
        }

        return json_encode($confirm_request_array, JSON_UNESCAPED_SLASHES);
    }

    /* 본인확인 서버 통신 예제 함수 */
    function sendPost($data, $url) {
        $curl = curl_init();                                                              // curl 초기화
        curl_setopt($curl, CURLOPT_URL, $url);                                            // 데이터를 전송 할 URL
        curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);                                 // 요청결과를 문자열로 반환
        curl_setopt($curl, CURLOPT_HTTPHEADER, array('Content-Type: application/json'));  // 전송 ContentType을 Json형식으로 설정
        curl_setopt($curl, CURLOPT_SSL_VERIFYPEER, false);                                // 원격 서버의 인증서가 유효한지 검사 여부
        curl_setopt($curl, CURLOPT_POSTFIELDS, $data);                                    // POST DATA
        curl_setopt($curl, CURLOPT_POST, true);                                           // POST 전송 여부
        $response = curl_exec($curl);                                                     // 전송
        curl_close($curl);                                                                // 연결해제

        return $response;
    }
?>

<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>mok_api_result</title>
    <script>
        let MOKResultJson = '<?php echo $MOK_RESULT ?>';
        MOKResultJson = JSON.parse(MOKResultJson);

        if (MOKResultJson.resultCode != '2000') {
            /* 오류발생시 */
            window.alert(MOKResultJson.resultCode + ', ' + MOKResultJson.resultMsg);
        } else {
            /* 정상작동시 */
            document.addEventListener("DOMContentLoaded", function () {
                document.getElementById("MOKResultJsonString").innerText = JSON.stringify(MOKResultJson);
            });
        }
    </script>
</head>
<body>
    <p id='MOKResultJsonString'>
    </p>
    <br>
<form action='<?php echo $MOK_API_REQUEST_PHP ?>' method="post">
        <input type="hidden" id="MOKConfirmRetryData" name="MOKConfirmRetryData" value='<?php echo $MOK_RESULT ?>' />
        <input type="submit" style="width:160px; height:30px; margin-left:5px; margin-bottom:15px;" value='재시도' />
        <a href='<?php echo $MOK_API_GET_TOKEN_PHP ?>'> 
            <input type="button" style="width:160px; height:30px; margin-left:5px; margin-bottom:15px;" value='처음페이지' />
        </a>
    </form>

</body>
</html>
    views/mok_api_result.ejs
     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
    <%# mok_api_server(mok_api_result) 처리 기능 참조 %>
<%#  오류발생시 %>

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
    <title>mobileOK_api_result</title>
</head>
<body>
    <% if ('2000' == data.resultCode) { %>
    <%-
    JSON.stringify(data)
    %>
    <% } else { %>
    <script>
    alert('<%- data.resultCode %>' + ', ' + '<%- data.resultMsg %>');
    document.addEventListener("DOMContentLoaded", function () {
    document.getElementById("MOKConfirmRetryData").value = '<%- MOKConfirmRetryDataJson %>';
});
    </script>

    <% } %>
    <p id='MOKResultJsonString'>
    </p>
    <br>
    <form action='<%- reqUrl.MOKRequestUri %>' method="post">
    <input type="hidden" id="MOKConfirmRetryData" name="MOKConfirmRetryData" value="" />
    <input type="submit" style="width:160px; height:30px; margin-left:5px; margin-bottom:15px;" value='재시도' />
    <a href='<%- reqUrl.MOKGetTokenUri %>'>
    <input type="button" style="width:160px; height:30px; margin-left:5px; margin-bottom:15px;" value='처음페이지' />
    </a>
    </form>
</body>
</html>
    mok_api_result.aspx
     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
    <%@ Page Language="C#" AutoEventWireup="true" CodeBehind="mok_api_result.aspx.cs" Inherits="mok_api_result"%>
<%@ Import Namespace="System" %>

<p>결과값 확인</p>

<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>mok_api_result</title>
    <script>
        const MOKResultJson = '<%= HttpUtility.JavaScriptStringEncode(MOKResult) %>';
        if (MOKResultJson.startsWith('%')) {
            window.alert(decodeURIComponent(MOKResultJson));
        } else if (MOKResultJson == null || MOKResultJson == "") {
            window.alert("MOKResult 값이 없습니다.");
        } else {
            const MOKResultJsonObject = JSON.parse(MOKResultJson);

            document.addEventListener("DOMContentLoaded", function () {
                if (MOKResultJsonObject.resultCode != '2000') {
                    /* 오류발생시 */
                    window.alert(MOKResultJsonObject.resultCode + ', ' + MOKResultJsonObject.resultMsg);
                } else {
                    /* 정상작동시 */
                    document.getElementById("MOKResultJsonString").innerText = JSON.stringify(MOKResultJsonObject);
                }
            });
        }
    </script>
</head>
<body>


<form runat="server" id="form1">
    <asp:HiddenField ID="MOKConfirmData" runat="server" />
    <asp:HiddenField ID="MOKAuthResendData" runat="server" />
</form>

<script>
    document.addEventListener("DOMContentLoaded", function () {
        const mokConfirmDataValue = document.getElementById('<%= MOKConfirmData.ClientID %>').value;
        const mokAuthResendDataValue = document.getElementById('<%= MOKAuthResendData.ClientID %>').value;

        document.getElementById('<%= MOKConfirmData.ClientID %>').value = mokConfirmDataValue;
        document.getElementById('<%= MOKAuthResendData.ClientID %>').value = mokAuthResendDataValue;

    });
</script>
<p id='MOKResultJsonString'>
</p>
<br>
<form action='<%= MOK_REQUEST_ASPX %>' method="post">
    <input type="hidden" id="MOKConfirmRetryData" name="MOKConfirmRetryData" value='<%= MOKResult %>' />
    <input type="submit" style="width:160px; height:30px; margin-left:5px; margin-bottom:15px;" value='재시도' />
    <a href='<%= MOK_GET_TOKEN_ASPX %>'> 
    <input type="button" style="width:160px; height:30px; margin-left:5px; margin-bottom:15px;" value='처음페이지' />
</a>
</form>
</body>
</html>
    mok_api_result.aspx.cs
      1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
    using System;
using System.Collections.Generic;
using System.Web;
using System.Web.Script.Services;
using System.Web.Services;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Threading.Tasks;
using System.Net.Http;
using System.Text;
using System.Web.UI.HtmlControls;
using System.Security.Authentication;

using System.IO;

using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using mokcrypto;
using System.Net;

public partial class mok_api_result : Page
{
    /*1. 본인확인 인증결과 MOKAuth API 또는 MOKResend API 요청 URL*/
    //private string MOK_CONFIRM_URL = "https://cert-dir.mobile-ok.com/agent/v1/confirm/request";  // 운영
    protected static string MOK_CONFIRM_URL = "https://scert-dir.mobile-ok.com/agent/v1/confirm/request";  // 개발

    // 재시도 버튼 클릭시 이동 aspx (mobileOK-Request aspx)//
    protected static string MOK_REQUEST_ASPX = "./mok_api_request.aspx";

    // 처음페이지 버튼 클릭시 이동 aspx (mobileOK-GetToken aspx)//
    protected static string MOK_GET_TOKEN_ASPX = "./mok_api_gettoken.aspx";

    MobileOkKeyManager mobileOK = new MobileOkKeyManager();
    protected string MOKResult = "";

    protected void Page_Load(object sender, EventArgs e)
    {
        var request = new HttpRequestMessage();
        try
        {
            /* 2. 본인확인 서비스 API 설정 */
            /* 키파일은 반드시 서버의 안전한 로컬경로에 별도 저장. 웹URL 경로에 파일이 있을경우 키파일이 외부에 노출될 수 있음 주의 */
            mobileOK.keyInit("/본인확인-API 키정보파일 Path/mok_keyInfo.dat", "키파일 패스워드");

            string MOKConfirmData = HttpContext.Current.Request.Form["MOKConfirmData"];
            MOKConfirmData = HttpUtility.UrlDecode(MOKConfirmData, System.Text.Encoding.UTF8);
            MOKResult = mobileOK_api_result(MOKConfirmData, mobileOK, request);
        }
        catch (MobileOKException ex)
        {
            alertASPX("에러: " + ex.Message);
        }
        catch (Exception ex)
        {
            alertASPX("에러: " + ex.Message);
        }
    }

    /* 본인확인 API 검증요청 예제 함수 */
    public string mobileOK_api_result(string MOKConfirmData, MobileOkKeyManager mobileOK, HttpRequestMessage request)
    {

        HttpContextBase context = new HttpContextWrapper(HttpContext.Current);
        HttpSessionStateBase session = context.Session;

        /* 3. 본인확인 검증요청 입력정보 설정 (아래 MOKConfirmRequestToJsonString() 참조) */
        JObject MOKConfirmRequestData = JObject.Parse(MOKConfirmData);
        string MOKConfirmRequest = "";

        string authNumber = Request.Form["authNumber"];
        string encryptMOKToken = MOKConfirmRequestData["encryptMOKToken"].ToString();
        string publicKey = MOKConfirmRequestData["publicKey"].ToString();

        if (!string.IsNullOrEmpty(authNumber))
        {
            MOKConfirmRequest = MOKConfirmRequestToJsonstring(mobileOK, encryptMOKToken, publicKey, authNumber);
        }
        else
        {
            MOKConfirmRequest = MOKConfirmRequestToJsonstring(mobileOK, encryptMOKToken, null, null);
        }

        /* 4. 본인확인 인증결과 확인 요청 */
        string MOKConfirmResponse = SendPost(MOK_CONFIRM_URL, MOKConfirmRequest);

        /* 5. 본인확인 결과 JSON 정보 복호화 */
        JObject decrpytResultJson = null;
        try
        {
            JObject MOKConfirmResponseJson = JObject.Parse(MOKConfirmResponse);

            if ((int)MOKConfirmResponseJson["resultCode"] != 2000)
            {
                JObject retryDataJson = new JObject();
                retryDataJson["publicKey"] = MOKConfirmRequestData["publicKey"];
                retryDataJson["encryptMOKToken"] = MOKConfirmRequestData["encryptMOKToken"].ToString();
                retryDataJson["resultCode"] = MOKConfirmResponseJson["resultCode"];
                retryDataJson["resultMsg"] = MOKConfirmResponseJson["resultMsg"];
                try
                {
                    string jsonString = JsonConvert.SerializeObject(retryDataJson);
                    return jsonString;
                }
                catch (DecoderFallbackException ex)
                {
                    return SetErrorMsg("URLEncoding에 실패했습니다.");
                }
            }
            /* 5.1. 본인확인 인증결과 응답 암호화데이터 복호화 */
            string encryptMOKResult = MOKConfirmResponseJson.GetValue("encryptMOKResult").ToString();
            decrpytResultJson = JObject.Parse(mobileOK.getResultJson(encryptMOKResult));
        }
        catch (MobileOKException e)
        {
            return SetErrorMsg(e.Message);
        }

        /* 6. 본인확인 인증결과 반환데이터 설정 */

        // 이용기관 거래 ID //
        string clientTxId = decrpytResultJson != null && decrpytResultJson["clientTxId"] != null ? decrpytResultJson["clientTxId"].ToString() : string.Empty;

        // 세션 내 요청 clientTxId 와 수신한 clientTxId 가 동일한지 반드시 비교
        //   - redirect 방식일 경우 페이지가 이동되면서 session 값이 변경될 수 있음, MicroSoft사에서 세션관리서버를 별도 이용하는것을 권고
        string sessionClientTxId = (string)HttpContext.Current.Session["sessionClientTxId"];

        if (!sessionClientTxId.Equals(clientTxId))
        {
            return SetErrorMsg("세션값에 저장된 거래ID 비교 실패");
        }

        // 사용자 이름 //
        string userName = decrpytResultJson != null && decrpytResultJson["userName"] != null ? decrpytResultJson["userName"].ToString() : string.Empty;
        // 이용기관 ID //
        string siteId = decrpytResultJson != null && decrpytResultJson["siteId"] != null ? decrpytResultJson["siteId"].ToString() : string.Empty;
        // 본인확인 거래 ID //
        string txId = decrpytResultJson != null && decrpytResultJson["txId"] != null ? decrpytResultJson["txId"].ToString() : string.Empty;
        // 서비스제공자(인증사업자) ID //
        string providerId = decrpytResultJson != null && decrpytResultJson["providerId"] != null ? decrpytResultJson["providerId"].ToString() : string.Empty;
        // 이용 서비스 유형 //
        string serviceType = decrpytResultJson != null && decrpytResultJson["serviceType"] != null ? decrpytResultJson["serviceType"].ToString() : string.Empty;
        // 사용자 CI //
        string ci = decrpytResultJson != null && decrpytResultJson["ci"] != null ? decrpytResultJson["ci"].ToString() : string.Empty;
        // 사용자 DI //
        string di = decrpytResultJson != null && decrpytResultJson["di"] != null ? decrpytResultJson["di"].ToString() : string.Empty;
        // 사용자 전화번호 //
        string userPhone = decrpytResultJson != null && decrpytResultJson["userPhone"] != null ? decrpytResultJson["userPhone"].ToString() : string.Empty;
        // 사용자 생년월일 //
        string userBirthday = decrpytResultJson != null && decrpytResultJson["userBirthday"] != null ? decrpytResultJson["userBirthday"].ToString() : string.Empty;
        // 사용자 성별 (1: 남자, 2: 여자) //
        string userGender = decrpytResultJson != null && decrpytResultJson["userGender"] != null ? decrpytResultJson["userGender"].ToString() : string.Empty;
        // 사용자 국적 (0: 내국인, 1: 외국인) //
        string userNation = decrpytResultJson != null && decrpytResultJson["userNation"] != null ? decrpytResultJson["userNation"].ToString() : string.Empty;
        /* 성인 인증 결과 (Y: 성인, N: 미성년자) SMS 성인여부 요청 시 응답 값이 존재*/
        string isAdult = decrpytResultJson != null && decrpytResultJson["isAdult"] != null ? decrpytResultJson["isAdult"].ToString() : string.Empty;
        // 본인확인 인증 종류 //
        string reqAuthType = decrpytResultJson != null && decrpytResultJson["reqAuthType"] != null ? decrpytResultJson["reqAuthType"].ToString() : string.Empty;
        // 본인확인 요청 시간 //
        string reqDate = decrpytResultJson != null && decrpytResultJson["reqDate"] != null ? decrpytResultJson["reqDate"].ToString() : string.Empty;
        // 본인확인 인증 서버 //
        string issuer = decrpytResultJson != null && decrpytResultJson["issuer"] != null ? decrpytResultJson["issuer"].ToString() : string.Empty;
        // 본인확인 인증 시간 //
        string issueDate = decrpytResultJson != null && decrpytResultJson["issueDate"] != null ? decrpytResultJson["issueDate"].ToString() : string.Empty;

        /* 7. 이용기관 응답데이터 셔션 및 검증유효시간 처리  */

        //.검증결과 생성 유효시간 검증 (검증결과 생성 후 10분 이내 검증 권고)
        DateTime nowDateTime = DateTime.Now;
        DateTime issueDateTime = DateTime.ParseExact(issueDate, "yyyy-MM-dd HH:mm:ss.fff", System.Globalization.CultureInfo.InvariantCulture).AddMinutes(10);

        int diff = DateTime.Compare(nowDateTime, issueDateTime);

        if (diff > 0)
        {
            return "-5|검증결과 토큰 생성 10분 경과 오류";
        }


        /* 8. 이용기관 서비스 기능 처리 */

        // - 이용기관에서 수신한 개인정보 검증 확인 처리

        // - 이용기관에서 수신한 CI 확인 처리

        /* 9. 본인확인 결과 응답 */

        // 복호화된 개인정보는 DB보관 또는 세션보관하여 개인정보 저장시 본인확인에서 획득한 정보로 저장하도록 처리 필요

        JObject resultJson = new JObject();
        resultJson["resultCode"] = "2000";
        resultJson["resultMsg"] = "성공";
        resultJson["userName"] = userName;

        return resultJson.ToString();
    }

    /* 본인확인-API 검증요청 정보 */
    public string MOKConfirmRequestToJsonstring(MobileOkKeyManager mobileOK, string encryptMOKToken, string publicKey, string authNumber)
    {
        JObject MOKconfirmRequestJson = new JObject();
        MOKconfirmRequestJson["encryptMOKToken"] = encryptMOKToken;

        if (!string.IsNullOrEmpty(authNumber))
        {
            JObject authNumberJson = new JObject();
            authNumberJson["authNumber"] = authNumber;
            string AuthString = JsonConvert.SerializeObject(authNumberJson);


            string encAuthNumber = mobileOK.RSAServerEncrypt(publicKey, AuthString);
            MOKconfirmRequestJson["encryptMOKVerifyInfo"] = encAuthNumber;
        }
        return MOKconfirmRequestJson.ToString();
    }

    /* 본인확인 서버 통신 예제 함수 */
    private string SendPost(string url, string json)
    {
        SecurityProtocolType originalProtocol = ServicePointManager.SecurityProtocol;
        try
        {
            ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12;
            HttpWebRequest request = (HttpWebRequest)WebRequest.Create(url);
            request.Method = "POST";
            request.ContentType = "application/json";

            byte[] data = Encoding.UTF8.GetBytes(json);
            request.ContentLength = data.Length;

            using (Stream stream = request.GetRequestStream())
            {
                stream.Write(data, 0, data.Length);
            }

            using (HttpWebResponse response = (HttpWebResponse)request.GetResponse())
            {
                if (response.StatusCode == HttpStatusCode.OK)
                {
                    using (StreamReader reader = new StreamReader(response.GetResponseStream(), Encoding.UTF8))
                    {
                        return reader.ReadToEnd();
                    }
                }
                else
                {
                    return null;
                }
            }
        }
        finally
        {
            // 기존 TLS 설정 복원
            ServicePointManager.SecurityProtocol = originalProtocol;
        }
    }


    //에러메시지 설정
    private string SetErrorMsg(string errorMsg)
    {
        string errJson = HttpUtility.UrlEncode(errorMsg);
        errJson = errJson.Replace("+", " ");
        return errJson;
    }

    //aspx 페이지 오류알람 출력
    private void alertASPX(string errorMsg)
    {
        string script = "window.onload = function() { alert('" + errorMsg + "'); };";
        Page.ClientScript.RegisterStartupScript(this.GetType(), "alert", script, true);
    }
}
    ResultController.cs
      1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
    using Microsoft.AspNetCore.Mvc;
using mokcrypto;
using Newtonsoft.Json.Linq;
using Newtonsoft.Json;
using System.Text;
using System.Web;
using System.Security.Authentication;
using System.Net.Http;
using Microsoft.Extensions.Logging;
using System.Threading.Tasks;
using System;
using System.IO;
using System.Collections.Generic;

namespace AspNetCoreAllInOne.Controllers
{
    public class ResultController : Controller
    {
        /* 1. 본인확인 인증결과 MOKConfirm API 또는 MOKResult API 요청 URL */
        //private string MOK_CONFIRM_URL = "https://cert-dir.mobile-ok.com/agent/v1/confirm/request";  // 운영
        private static string MOK_CONFIRM_URL = "https://scert-dir.mobile-ok.com/agent/v1/confirm/request";  // 개발

        [HttpPost]
        public async Task<IActionResult> mok_api_result()
        {
            /* 2. 본인확인 서비스 함수 초기화 */
            MobileOkKeyManager mobileOK = new MobileOkKeyManager();

            try
            {
                /* 키파일은 반드시 서버의 안전한 로컬경로에 별도 저장. 웹URL 경로에 파일이 있을경우 키파일이 외부에 노출될 수 있음 주의 */
                mobileOK.keyInit("/본인확인-API 키정보파일 Path/mok_keyInfo.dat", "키파일 패스워드");

                string MOKConfirmData = HttpContext.Request.Form["MOKConfirmData"];
                if (string.IsNullOrEmpty(MOKConfirmData))
                {
                    Console.WriteLine("-1|본인확인 요청 MOKToken이 없습니다.");
                }
                string MOKConfirmData1 = HttpUtility.UrlDecode(MOKConfirmData, System.Text.Encoding.UTF8);
                ViewData["message"] = await mobileOK_api_result(MOKConfirmData1, mobileOK);
            }
            catch (MobileOKException ex)
            {
                ViewData["message"] = ex.Message;
            }

            return View();
        }

        /* 본인확인 API 검증요청 예제 함수 */
        public async Task<string> mobileOK_api_result(string MOKConfirmData, MobileOkKeyManager mobileOK)
        {
            /* 3. 본인확인 검증요청 입력정보 설정 (아래 MOKConfirmRequestToJsonString() 참조) */
            JObject MOKConfirmRequestData = JObject.Parse(MOKConfirmData);
            //MOKConfirmRequestData.ToString();
            string MOKConfirmRequest = "";

            string authNumber = Request.Form["authNumber"];
            string encryptMOKToken = MOKConfirmRequestData["encryptMOKToken"].ToString();
            string publicKey = MOKConfirmRequestData["publicKey"].ToString();

            if (!string.IsNullOrEmpty(authNumber))
            {
                MOKConfirmRequest = MOKConfirmRequestToJsonstring(
                    mobileOK
                    , encryptMOKToken   /* MOK_API_AUTH_REQUEST에서 발급 받은 encryptMOKToken */
                    , publicKey         /* MOK_API_GET_TOKEN에서 발급 받은 publicKey */
                    , authNumber        /* 본인확인 인증요청으로 수신한 인증번호(authNumber)" */
                    );
            }
            else
            {
                MOKConfirmRequest = MOKConfirmRequestToJsonstring(mobileOK
                    , encryptMOKToken   /* MOK_API_AUTH_REQUEST에서 발급 받은 encryptMOKToken */
                    , null              /* MOK_API_GET_TOKEN에서 발급 받은 publicKey */
                    , null              /* 본인확인 인증요청으로 수신한 인증번호(authNumber)" */
                    );
            }

            /* 4. 본인확인 인증결과 확인 요청 */
            string MOKConfirmResponse = await SendPost(MOK_CONFIRM_URL, MOKConfirmRequest);

            /* 5. 본인확인 결과 JSON 정보 복호화 */
            JObject decrpytResultJson = null;
            try
            {
                JObject MOKConfirmResponseJson = JObject.Parse(MOKConfirmResponse);

                if ((int)MOKConfirmResponseJson["resultCode"] != 2000)
                {
                    JObject retryDataJson = new JObject();
                    retryDataJson["publicKey"] = MOKConfirmRequestData["publicKey"];
                    retryDataJson["encryptMOKToken"] = MOKConfirmRequestData["encryptMOKToken"].ToString();
                    retryDataJson["resultCode"] = MOKConfirmResponseJson["resultCode"];
                    retryDataJson["resultMsg"] = MOKConfirmResponseJson["resultMsg"];
                    try
                    {
                        string jsonString = JsonConvert.SerializeObject(retryDataJson);
                        return jsonString;
                    }
                    catch (DecoderFallbackException ex)
                    {
                        return "URLEncoding에 실패했습니다.";
                    }
                }
                /* 5.1. 본인확인 인증결과 응답 암호화데이터 복호화 */
                string encryptMOKResult = MOKConfirmResponseJson.GetValue("encryptMOKResult").ToString();
                decrpytResultJson = JObject.Parse(mobileOK.getResultJson(encryptMOKResult));
            }
            catch (MobileOKException e)
            {
                return e.Message;
            }

            /* 6. 본인확인 인증결과 반환데이터 설정 */

            //    세션 내 요청 clientTxId 와 수신한 clientTxId 가 동일한지 반드시 비교
            // 이용기관 거래 ID //
            string clientTxId = decrpytResultJson != null && decrpytResultJson["clientTxId"] != null ? decrpytResultJson["clientTxId"].ToString() : string.Empty;     

            //   - redirect 방식일 경우 페이지가 이동되면서 session 값이 변경될 수 있음, MicroSoft사에서 세션관리서버를 별도 이용하는것을 권고
            string sessionClientTxId = HttpContext.Session.GetString("sessionClientTxId");
            if (!sessionClientTxId.Equals(clientTxId))
            {
            return "-4|세션값에 저장된 거래ID 비교 실패";
            }

            // 사용자 이름 //
            string userName = decrpytResultJson != null && decrpytResultJson["userName"] != null ? decrpytResultJson["userName"].ToString() : string.Empty;
            // 이용기관 ID //
            string siteId = decrpytResultJson != null && decrpytResultJson["siteId"] != null ? decrpytResultJson["siteId"].ToString() : string.Empty;
            // 본인확인 거래 ID //
            string txId = decrpytResultJson != null && decrpytResultJson["txId"] != null ? decrpytResultJson["txId"].ToString() : string.Empty;
            // 서비스제공자(인증사업자) ID //
            string providerId = decrpytResultJson != null && decrpytResultJson["providerId"] != null ? decrpytResultJson["providerId"].ToString() : string.Empty;
            // 이용 서비스 유형 //
            string serviceType = decrpytResultJson != null && decrpytResultJson["serviceType"] != null ? decrpytResultJson["serviceType"].ToString() : string.Empty;
            // 사용자 CI //
            string ci = decrpytResultJson != null && decrpytResultJson["ci"] != null ? decrpytResultJson["ci"].ToString() : string.Empty;
            // 사용자 DI //
            string di = decrpytResultJson != null && decrpytResultJson["di"] != null ? decrpytResultJson["di"].ToString() : string.Empty;
            // 사용자 전화번호 //
            string userPhone = decrpytResultJson != null && decrpytResultJson["userPhone"] != null ? decrpytResultJson["userPhone"].ToString() : string.Empty;
            // 사용자 생년월일 //
            string userBirthday = decrpytResultJson != null && decrpytResultJson["userBirthday"] != null ? decrpytResultJson["userBirthday"].ToString() : string.Empty;
            // 사용자 성별 (1: 남자, 2: 여자) //
            string userGender = decrpytResultJson != null && decrpytResultJson["userGender"] != null ? decrpytResultJson["userGender"].ToString() : string.Empty;
            // 사용자 국적 (0: 내국인, 1: 외국인) //
            string userNation = decrpytResultJson != null && decrpytResultJson["userNation"] != null ? decrpytResultJson["userNation"].ToString() : string.Empty;
            /* 성인 인증 결과 (Y: 성인, N: 미성년자) SMS 성인여부 요청 시 응답 값이 존재*/
            string isAdult = decrpytResultJson != null && decrpytResultJson["isAdult"] != null ? decrpytResultJson["isAdult"].ToString() : string.Empty;
            // 본인확인 인증 종류 //
            string reqAuthType = decrpytResultJson != null && decrpytResultJson["reqAuthType"] != null ? decrpytResultJson["reqAuthType"].ToString() : string.Empty;
            // 본인확인 요청 시간 //
            string reqDate = decrpytResultJson != null && decrpytResultJson["reqDate"] != null ? decrpytResultJson["reqDate"].ToString() : string.Empty;
            // 본인확인 인증 서버 //
            string issuer = decrpytResultJson != null && decrpytResultJson["issuer"] != null ? decrpytResultJson["issuer"].ToString() : string.Empty;
            // 본인확인 인증 시간 //
            string issueDate = decrpytResultJson != null && decrpytResultJson["issueDate"] != null ? decrpytResultJson["issueDate"].ToString() : string.Empty;

            /* 7. 이용기관 응답데이터 셔션 및 검증유효시간 처리  */

            // 검증정보 유효시간 검증 (본인확인 결과인증 후 10분 이내 검증 권고)
            DateTime nowDateTime = DateTime.Now;
            DateTime issueDateTime = DateTime.ParseExact(issueDate, "yyyy-MM-dd HH:mm:ss.fff", System.Globalization.CultureInfo.InvariantCulture).AddMinutes(10);

            int diff = DateTime.Compare(nowDateTime, issueDateTime);

            if (diff > 0)
            {
                return "-5|검증결과 토큰 생성 10분 경과 오류";
            }


            /* 8. 이용기관 서비스 기능 처리 */

            // - 이용기관에서 수신한 개인정보 검증 확인 처리

            // - 이용기관에서 수신한 CI 확인 처리

            /* 9. 본인확인 결과 응답 */

            // 복호화된 개인정보는 DB보관 또는 세션보관하여 개인정보 저장시 본인확인에서 획득한 정보로 저장하도록 처리 필요

            JObject resultJson = new JObject();
            resultJson["resultCode"] = "2000";
            resultJson["resultMsg"] = "성공";
            resultJson["userName"] = userName;

            return resultJson.ToString();
        }

        /* 본인확인-API 검증요청 정보 */
        private string MOKConfirmRequestToJsonstring(MobileOkKeyManager mobileOK, string encryptMOKToken, string publicKey, string authNumber)
        {
            JObject MOKconfirmRequestJson = new JObject();
            MOKconfirmRequestJson["encryptMOKToken"] = encryptMOKToken;

            if (!string.IsNullOrEmpty(authNumber))
            {
                JObject authNumberJson = new JObject();
                authNumberJson["authNumber"] = authNumber;
                string AuthString = JsonConvert.SerializeObject(authNumberJson);


                string encAuthNumber = mobileOK.RSAServerEncrypt(publicKey, AuthString);
                MOKconfirmRequestJson["encryptMOKVerifyInfo"] = encAuthNumber;
            }
            return MOKconfirmRequestJson.ToString();
        }

        /* 본인확인 서버 통신 예제 함수 */
        private async Task<string> SendPost(string url, string json)
        {
            try
            {
                HttpClient client = new HttpClient();

                var content = new StringContent(json, System.Text.Encoding.UTF8, "application/json");

                var response = await client.PostAsync(url, content);

                if (response.IsSuccessStatusCode)
                {
                    string responseString = await response.Content.ReadAsStringAsync();
                    return responseString;
                }
                else
                {
                    return null;
                }
            }
            catch (HttpRequestException ex)
            {
                Console.WriteLine("HttpRequestException: " + ex.Message);
                return null;
            }
            catch (TaskCanceledException ex)
            {
                Console.WriteLine("TaskCanceledException: " + ex.Message);
                return null;
            }
            catch (IOException ex)
            {
                Console.WriteLine("IOException: " + ex.Message);
                return null;
            }
        }
    }
}
    mok_api_result.cshtml
     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
    @{
    // 재시도 버튼 클릭시 이동
    string MOK_REQUEST_CSHTML = "./mok_api_request";
    // 처음페이지 버튼 클릭시 이동
    string MOK_GET_TOKEN_CSHTML = "./mok_api_gettoken";
}

<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>mok_api_result</title>
    <script>
        const MOKResultJson = `@Html.Raw(ViewData["message"])`

        document.addEventListener("DOMContentLoaded", function () {
            var MOKAuthRequestJsonObject;

            try {
                MOKAuthRequestJsonObject = JSON.parse(MOKResultJson);

            if (MOKAuthRequestJsonObject.resultCode != '2000') {
                    /* 오류발생시 */
                    window.alert(MOKAuthRequestJsonObject.resultCode + ', ' + MOKAuthRequestJsonObject.resultMsg);
                    document.getElementById("MOKConfirmRetryData").value = JSON.stringify(MOKAuthRequestJsonObject);
                } else {
                    /* 정상작동시 */
                    document.getElementById("MOKResultJsonString").innerText = JSON.stringify(MOKAuthRequestJsonObject);
                }
            } catch (e) {
                window.alert(MOKResultJson);
            }
        });
    </script>
</head>
<body>
    <p id='MOKResultJsonString'>
    </p>
    <br>
    <form action=@MOK_REQUEST_CSHTML method="post">
        <input type="hidden" id="MOKConfirmRetryData" name="MOKConfirmRetryData" value='' />
        <input type="submit" style="width:160px; height:30px; margin-left:5px; margin-bottom:15px;" value='재시도' />
        <a href=@MOK_GET_TOKEN_CSHTML>
            <input type="button" style="width:160px; height:30px; margin-left:5px; margin-bottom:15px;" value='처음페이지' />
        </a>
    </form>
</body>
</html>

8. 본인확인-API 오류코드

에러코드 설명 고객 메시지 운영시 주요 에러코드
2000 성공 성공 ●
2910 휴대폰 통신사 가입자 명의인증 실패 입력하신 정보가 올바르지 않습니다. 확인 후 다시 시도해주세요 ●
2910 휴대폰 통신사 사용자(소유자) 인증번호 검증 실패 입력하신 정보가 올바르지 않습니다. 인증번호를 확인해주세요. ●
3001 인증요청 정보에 이름, 전화번호 등 요청문 필수 항목 필드를 확인할 수 없습니다. 입력값 오류가 발생했습니다. (필수 입력값 오류)
처음부터 다시 시도해 주세요.		 ●
4000 검증 완료 후 결과확인토큰(KeyToken)으로 검증 결과를 재요청하는 경우 발생합니다. (결과검증 성공시 재요청 불가)
처리 완료 후 10분이 넘어 결과 전달 유효시간이 초과할 경우 발생합니다.		 이미 완료 되었거나 허용시간을 초과 한 인증 요청입니다. 확인 후 다시 시도해 주세요. ●
4001 거래ID 및 서비스ID 로 서비스 조회가 안되는 경우 발생합니다.
인증요청 후 세션 유지시간인 7분을 초과하여 조회가 되지 않을때 발생 할 수 있습니다.		 인증 진행사항을 확인할 수 없습니다.
처음부터 다시 시도해 주세요.		 ●
4003 인증번호 재발송시 거래ID 및 서비스ID를 서비스에서 확인할 수 없습니다.
인증요청을 하지 않았거나 인증요청 후 세션 유지시간인 7분을 초과하여 때 발생 할 수 있습니다.
상세코드
- 4002, 4003 : 요청 시 저장한 제한횟수등 진행사항이 없음
- 4004 : ARS 및 SMS OTP 요청을 찾을 수 없는 경우		 이미 완료 되었거나 허용시간을 초과 한 인증 요청입니다.
확인 후 다시 시도해 주세요. (상세코드)		 ●
4007 이미 서비스내에 이용중인 거래ID가 있습니다. 다시 검증을 위해서는 재시도가 필요합니다. 이미 진행중인 인증 요청입니다.
처음부터 다시 시도해 주세요.		 ●
4013 이용자가 입력한 SMS 점유인증 및 ARS 입력 인증번호가 올바르지 않은 경우 발생합니다. 인증 요청 정보가 올바르지 않습니다(인증번호)
확인 후 다시 시도해 주세요.		 ●
4016 인증요청 정보중 필수 항목 데이터가 없는 경우에 발생합니다. 통신사에 요청된 정보가 올바르지 않습니다.
확인 후 다시 시도해주세요.		 ●
4018 SMS 인증번호 검증시 요청된 서비스ID로 인증요청 정보를 찾을 수 없을경우 발생합니다. 인증요청이 요청되지 않았거나 검증완료 후 검증이 재요청된 경우, 인증 요청 후 10분이 넘어 세션타임이 초과하여 발생합니다. 이미 완료 되었거나 허용시간을 초과 한 인증 요청입니다.
확인 후 다시 시도해 주세요.		 ●
4022 KT 법인 사용자가 본인확인 인증시 SMS로 전송된 WEB LINK 인증을 진행하지 않은 경우에 발생합니다. 인증 요청에 실패하였습니다. KT법인명의 본인확인을 위해 수신한 SMS 안내에 따라 추가 인증을 진행해주세요. ●
4023 사용자가 SKT 부가서비스(휴대폰번호보호서비스, 인증보호서비스 등) 가입자고 부가서비스 2차 인증 미완료시 발생합니다. 부가서비스 인증 완료되지 않았습니다.
부가서비스 인증을 하신 후 다시 진행해 주세요.		 ●
4101 이용기관의 토큰 요청정보가 올바르지 않습니다. 토큰 발급 시 필요한 필수값 및 설정이 맞는지 확인이 필요합니다. 인증 요청 정보가 올바르지 않습니다.
확인 후 다시 시도해 주세요.		 ●
4150 요청된 거래ID로 검증완료 후 개인정보결과가 리턴되어 검증요청을 재전송할 수 없는 경우 발생합니다. 이미 처리 완료된 인증 요청입니다. ●
4301 본인확인 검증요청 제한 횟수인 3회를 초과하여 발생합니다. 검증요청 제한 횟수를 초과하였습니다.
처음부터 다시 시도해 주세요.		 ●
4302 인증번호 SMS 재전송 횟수인 3회를 초과하여 발생합니다. 인증요청 제한 횟수를 초과하였습니다.
처음부터 다시 시도해 주세요.		 ●
4500 ARS 인증결과를 확인 할 수 없습니다. ARS 통화가 완료되지 않거나 ARS 응답이 수신되지 않아 발생할 수 있습니다. ARS인증 결과를 찾을 수 없습니다.
확인 후 다시 시도해 주세요.		 ●
4501 사용자 ARS 전화요청이 성공한 직후, 전화걸기 재 요청 시 처음 ARS 결과가 아직 수신되지 않아 해당 문구가 안내됩니다. ARS 전화가 현재 진행 중입니다.
반복적으로 해당 메시지가 수신된 경우, 처음부터 다시 시도해 주세요		 ●
4502 사용자 ARS 전화를 수신 받아 전화연결이 정상적으로 완료된 이후, 다시 전화걸기를 시도하신 경우 해당 문구가 안내됩니다. ARS 인증을 이미 진행하셨습니다. ●
4602 사용자 ARS 전화요청시 인증번호가 불일치 한 경우 발생합니다. 인증 요청 정보가 올바르지 않습니다(인증번호)
확인 후 다시 시도해 주세요.		 ●
4604 사용자 ARS 전화요청시 인증번호를 검증하지 않고 취소 (사용자가 ARS 전화를 받고, “#” 버튼을 눌러 도중에 취소한 경우)하여 인증 요청이 종료된 경우 발생합니다. 인증 요청이 취소되었습니다.
처음부터 다시 시도해 주세요.		 ●
4610 사용자 ARS 전화요청시 없는 번호인 경우 발생합니다. 인증 요청 정보가 올바르지 않습니다(잘못된 휴대폰번호)
확인 후 다시 시도해 주세요.		 ●
4611 사용자 ARS 전화요청시 사용자가 수신 거부 한 경우 발생합니다. 인증 요청 정보가 올바르지 않습니다(수신거부)
확인 후 다시 시도해 주세요.		 ●
4612 사용자 ARS 전화요청시 ARS 전화를 안 받은 경우 발생합니다. 인증 요청이 취소되었습니다.
처음부터 다시 시도해 주세요.		 ●
4613 사용자 ARS 전화요청시 착신 전환된 사용자의 경우 발생합니다. 인증 요청이 취소되었습니다.
처음부터 다시 시도해 주세요.		 ●
4620 사용자 ARS 전화요청시 ARS 전화를 받고, 고객이 전화를 끊은 경우 발생합니다. 인증 요청이 취소되었습니다.
처음부터 다시 시도해 주세요.		 ●
4624 사용자 ARS 전화요청시 사용자가 ARS 전화를 받고, 아무 입력이 없어 종료된 경우 발생합니다. 인증 요청이 취소되었습니다.
처음부터 다시 시도해 주세요.		 ●
4641 사용자 ARS 전화요청시 사용자가 통화중인 경우 발생합니다. 인증 요청이 취소되었습니다.
처음부터 다시 시도해 주세요.		 ●
4642 사용자 ARS 전화요청시 사용자 휴대폰 전원이 꺼져서 ARS 진행을 못한 경우 발생합니다. 인증 요청이 취소되었습니다.
처음부터 다시 시도해 주세요.		 ●
4698 사용자 ARS 전화요청시 OTP검증번호 입력 후 통신사와의 검증요청시 오류결과를 받을 경우 발생합니다. ARS서비스에 오류가 발생하였습니니다(ARS사업자오류)
관리자에게 문의 해 주세요.		 ●
4699 사용자 ARS 전화요청시 ARS전화요청 서버가 오류가 발생한 경우입니다. ARS서비스에 오류가 발생하였습니니다(ARS사업자오류)
관리자에게 문의 해 주세요.		 ●
6701 PASS 미가입 사용자일 경우 발생합니다. 상세코드 참고
- 6030: T 인증 미가입
- 6210: PASS 인증실패(미등록 인증서비스코드)
- 6116: FIDO 미등록 서비스코드		 PASS 서비스 미가입자입니다.
가입 후 다시 시도해주세요.(상세코드)		 ●
6702 PASS 인증 미진행시 발생합니다. 상세코드 참고
- 6061: 간편본인확인 진행중
- 6032: T 인증 대기중
- 6114 : FIDO 미진행 처리중		 PASS 인증이 완료되지 않았습니다.
인증 후 다시 시도해 주세요.(상세코드)		 ●
6703 PASS 인증실패 사용자일 경우 발생합니다. 상세코드 참고
- 6207: PASS 인증실패(인증 미진행 / 처리중)
- 6202: PASS 인증실패(간편본인확인 요청 처리 완료 전 간편본인확인 결과 확인 요청)
- 6212 : PASS 인증실패(앱미설치/미가입/미구동 등)		 PASS 인증이 완료되지 않았습니다.
인증 후 다시 시도해 주세요.(상세코드)		 ●
6704 PASS앱 미설치 사용자일 경우 발생합니다. 상세코드 참고
- 6113: FIDO App 미설치
- 6209: PASS 인증실패(App미설치 및 AppToken검증실패)
- 6041 : PASS 앱 미 설치 에러
- 6060 : 간편본인확인 미가입		 PASS 앱이 설치되지 않았습니다.
앱 설치 후 다시 시도해 주세요.(상세코드)		 ●
6705 PASS 고객인증 실패시 발생합니다. 상세코드 참고
- 6205: PASS 고객인증 실패(사용자취소,PIN등 불일치 등)
- 6110: FIDO 고객인증실패
- 6035 : T 인증 사용자 취소
- 6112 : FIDO 민앤지 인증실패
- 6033 : T 인증 PIN 입력		 PASS 인증 요청이 취소되었습니다.
처음부터 다시 시도해 주세요.(상세코드)		 ●
6706 PASS 인증 유효시간 초과시 발생합니다. 상세코드 참고
- 6034: T 인증 유효시간 초과
- 6203: PASS 인증실패(인증 TIMEOUT)
- 6115 : FIDO TIME OUT		 유효시간이 만료되었습니다.
처음부터 다시 시도해 주세요.(상세코드)		 ●
6707 PASS 인증 가능 휴대폰이 아닐경우 발생합니다. 상세코드 참고
- 6036: 스마트폰 아님
- 6063: 스마트폰 아님
- 6211 : PASS 인증실패(미등록 인증장치)
- 6117 : FIDO 미등록 인증장치		 PASS 인증을 사용할 수 없습니다.
문자 (SMS) 인증으로 다시 시도해 주세요. (상세코드)		 ●
6751 PASS 사용자휴대폰 14세 미만 사용자일 경우 발생합니다. PASS 인증은 만 15세 이상부터 이용가능합니다.
문자 (SMS) 인증으로 다시 시도해 주세요.		 ●
6752 PASS 앱 PUSH발송 실패일 경우 발생합니다. PUSH 발송에 실패하였습니다.
잠시 후 다시 시도해 주세요.		 ●
6753 PASS T 인증앱 재등록 실패일 경우 발생합니다. PASS 인증 중 오류가 발생하였습니다.
PASS 인증 앱 재설치 후 다시 시도해주세요.		 ●
6754 PASS LGU+ 알뜰폰 가입자일 경우 발생합니다. LGU+ 알뜰폰 가입자입니다. 통신사를 알뜰폰으로 선택하여 다시 시도해 주세요. ●
6755 PASS 본인확인 차단고객(App설정)일 경우 발생합니다. 본인확인서비스 이용이 차단되어 있습니다.
차단 해지 후 다시 시도해 주세요.		 ●
6756 PASS 본인확인 메시지 발송 차단 고객(App설정) 경우 발생합니다. 메시지 발송이 차단되어 있습니다.
차단 해지 후 다시 이용해 주세요.
(설정-> 메시지-> 차단된 연락처->해지할 연락처 선택).		 ●
6757 SKT인증앱 미설치 사용자 휴대폰에서 발생합니다. SKT 휴대폰인증보호 서비스 앱이 설치되지 않았습니다.
앱 설치 후 다시 시도해 주세요.		 ●
9998 인증요청 정보중 필수 항목 데이터가 없는 경우에 발생합니다. 인증 요청 정보가 올바르지 않습니다.
확인 후 다시 시도해 주세요.		 ●
9999 서비스 중 알 수 없는 오류(예외처리 등)가 발생되었으며 자세한 사항은 본인확인서비스 운영담당자에게 문의 바랍니다. 원인을 알 수 없는 오류가 발생했습니다.
잠시 후 다시 시도해 주세요		 ●
에러코드 설명 고객 메시지 운영시 주요 에러코드
4005 통신사 SMS 인증외 인증수단(ARS 등의)인증시 알수없는 서비스제공자가 설정된 경우 발생합니다. ARS서비스에 오류가 발생하였습니니다(ARS사업자정보)
관리자에게 문의 해 주세요.
4006 서비스 본인확인 인증 Type 코드 올바르게 입력되어 요청되지 않았습니다. reqAuthType 의 “SMS”, “PASS” 설정 인증 요청 정보가 올바르지 않습니다.(인증구분)
확인 후 다시 시도해 주세요.
4008 통신사 또는 인증사업자와의 연결에 이상이 발생하였습니다. 대부분 재시도시 사용가능 하나 오류가 지속될경우 본인확인서비스 운영담당자에게 문의 바랍니다. 선택하신 본인확인 서비스와 연결에 실패했습니다.
잠시후 다시 시도해 주세요.
4009 이용기관 에서 등록한 ARS코드가 서비스에 허용된 ARS가 다릅니다. 설정이 맞는지 본인확인서비스 운영담당자에게 문의 바랍니다. ARS서비스에 오류가 발생하였습니니다(ARS코드)
관리자에게 문의 해 주세요.
4010 이용기관에서 요청한 PASS 인증요청 정보 중 통신사 정보가 올바르지 않습니다. 인증 요청 정보가 올바르지 않습니다(통신사정보) 확인 후 다시 시도해 주세요.
4011 ARS 서비스 연결 요청에 실패하였습니다. 대부분 재시도시 사용가능 하나 오류가 지속될 경우 본인확인서비스 운영담당자에게 문의 바랍니다. ARS 서비스 연결 요청에 실패하였습니다.
잠시 후 다시 시도해 주세요.
4012 인증번호 SMS 를 사용자 휴대폰 전송하는데 실패하였습니다. 대부분 재시도시 사용가능 하나 오류가 지속될 경우 본인확인서비스 운영담당자에게 문의 바랍니다. 인증요청 메시지 전송에 실패하였습니다.
잠시 후 다시 시도해 주세요.
4014 서비스 이용상품 코드가 올바르게 입력되어 요청되지 않았습니다. serviceType 의 “telcoAuth” : 휴대폰본인확인, “telcoAuth-LMS” : 휴대폰본인확인 LMS 설정 등 인증 요청 정보가 올바르지 않습니다(상품정보)
확인 후 다시 시도해 주세요.
4015 PASS등 인증 및 검증 재발송을 허용하지 않는 서비스 진행시 재발송을 요청한 경우 발생합니다. 재전송을 지원하지 않는 서비스입니다.
확인 후 다시 시도해주세요.
4017 인증요청 정보중 통신사 정보가 없거나 정의되지 않은 통신사 정보가 있는 경우에 발생합니다. 인증 요청 정보가 올바르지 않습니다(통신사정보)
확인 후 다시 시도해 주세요.
4020 ARS 인증시 검증결과가 실패인 경우 발생합니다. 예를들어 사용자가 ARS 전화를 받지 않거나 잘못된 정보를 입력한경우가 있습니다. 인증 요청 정보가 올바르지 않습니다(검증실패)
확인 후 다시 시도해 주세요.
4021 재전송을 지원하지 않는 서비스에서 재전송을 요청할 경우에 발생합니다. 재전송을 지원하지 않는 서비스입니다.
확인 후 다시 시도해주세요.
5003 본인확인 인증요청 정보중 사용자 이름 정보가 올바르지 않습니다. 인증 요청 정보가 올바르지 않습니다(이름)
확인 후 다시 시도해 주세요.
5004 본인확인 인증요청 정보중 사용자 생년월일 정보가 올바르지 않습니다. 인증 요청 정보가 올바르지 않습니다(생년월일)
확인 후 다시 시도해 주세요.
5005 본인확인 인증요청 정보중 사용자 성별 정보가 올바르지 않습니다. 인증 요청 정보가 올바르지 않습니다(성별)
확인 후 다시 시도해 주세요.
5007 본인확인 인증요청 정보중 ReqAuthType이 올바르지 않습니다. reqAuthType 의 “SMS”, “PASS” 설정 인증 요청 정보가 올바르지 않습니다(인증구분)
관리자에게 문의해 주세요.
5008 본인확인 인증요청 정보중 ServiceType이 올바르지 않습니다. serviceType 의 “telcoAuth” : 휴대폰본인확인, “telcoAuth-LMS” : 휴대폰본인확인 LMS 설정 등 인증 요청 정보가 올바르지 않습니다(상품정보)
관리자에게 문의해 주세요.
5009 본인확인 인증요청 정보중 등록된 이용기관 ID가 올바르지 않습니다. 인증 요청 정보가 올바르지 않습니다(이용기관정보)
관리자에게 문의해 주세요.
5010 본인확인 인증요청 정보중 통신사 정보가 없거나 정의되지 않은 통신사 정보가 있는 경우에 발생합니다. 인증 요청 정보가 올바르지 않습니다(통신사정보)
확인 후 다시 시도해 주세요.
5011 본인확인 검증요청 정보중 검증번호(SMS OTP 또는 ARS 입력정보)가 올바르지 않습니다. 인증 요청 정보가 올바르지 않습니다(인증번호)
확인 후 다시 시도해 주세요.
5012 본인확인 인증요청 정보중 사용자 휴대폰번호가 올바르지 않습니다. 인증 요청 정보가 올바르지 않습니다(휴대폰번호)
확인 후 다시 시도해 주세요.
5013 본인확인 인증요청 정보중 이용기관 ID가 올바르지 않습니다. 인증 요청 정보가 올바르지 않습니다(이용기관)
관리자에게 문의해 주세요.
5014 본인확인 요청 이용기관 거래ID가 올바르지 않습니다. 인증 요청 정보가 올바르지 않습니다(이용기관 거래ID)
관리자에게 문의해 주세요.
5015 본인확인 요청 통신사 요청 거래ID가 올바르지 않습니다. 본인확인 요청 응답시 수신한 토큰으로 검증요청을 했는지 확인 바랍니다. 인증 요청 정보가 올바르지 않습니다(요청 거래ID)
관리자에게 문의해 주세요.
5016 본인확인 검증 통신사 응답 거래ID가 올바르지 않습니다. 본인확인 요청 응답시 수신한 토큰으로 검증요청을 했는지 확인 바랍니다. 인증 요청 정보가 올바르지 않습니다(검증 거래ID)
관리자에게 문의해 주세요.
5017 등록된 이용기관 ID 정보를 찾을 수 없습니다. 설정이 맞는지 본인확인서비스 운영담당자에게 문의 바랍니다. 인증 요청 정보가 올바르지 않습니다(이용기관정보)
관리자에게 문의해 주세요.
5018 ARS 인증요청 정보중 사용자 생년월일 입력형식이 맞지 않습니다. 예시) 8자리 년월일 20011010 인증 요청 정보가 올바르지 않습니다(생년월일)
확인 후 다시 시도해 주세요.
5019 ARS 검증요청 정보중 ARS 거래ID 정보가 없습니다. 본인확인 요청 응답시 수신한 토큰으로 검증요청을 했는지 확인 바랍니다. ARS서비스에 오류가 발생하였습니니다(ARS 거래ID)
관리자에게 문의 해 주세요.
5020 본인확인 표준창에서 통신사 정보 및 동의한 약관등 필수정보가 입력되지 않았습니다. 인증 요청 정보가 올바르지 않습니다(통신사정보)
관리자에게 문의해 주세요.
5021 모바일웹 본인확인 표준창에서 통신사 정보 및 동의한 약관등 필수정보가 입력되지 않았습니다. 인증 요청 정보가 올바르지 않습니다(통신사정보)
관리자에게 문의해 주세요.
5023 등록된 이용기관 서비스 ID 정보를 찾을 수 없습니다. 본인확인 담당자에게 받은 키파일이 올바른지 확인 바랍니다. 인증 요청 정보가 올바르지 않습니다(이용기관)
관리자에게 문의해 주세요.
5024 검증요청 정보가 올바르지 않거나 검증을 하지 않은 경우 발생합니다. 인증 요청 정보가 올바르지 않습니다(검증실패)
확인 후 다시 시도해 주세요.
5027 이용이 중지된 이용기관 입니다. 본인확인서비스 운영담당자에게 문의 바랍니다. 인증 요청 정보가 올바르지 않습니다(이용기관)
관리자에게 문의해 주세요.
5028 이용기관에 등록되지 않은 도메인에 결과를 응답요청하였습니다. 등록된 도메인으로 변경하거나 본인확인서비스 운영담당자를 통해 추가 등록 바랍니다. 인증 요청 정보가 올바르지 않습니다(이용기관)
관리자에게 문의해 주세요.
5029 본인확인 OTP 검증 시 인증번호의 형식이 올바르지 않음 인증 요청 정보가 올바르지 않습니다(인증번호 향식오류)
확인 후 다시 시도해 주세요.
5030 키보드 보안 복호화 중 문제가 발생했습니다. 인증 요청 정보가 올바르지 않습니다(키보드보안 복호화실패)
확인 후 다시 시도해 주세요.
5031 암호화된 개인정보 처리시 오류가 발생했습니다. 원인을 알 수 없는 오류가 발생했습니다.
잠시 후 다시 시도해 주세요
5032 요청한 브라우져의 정보 검증시 오류가 발생했습니다. 원인을 알 수 없는 오류가 발생했습니다.
잠시 후 다시 시도해 주세요
5033 최초 토큰발급 이후 10분이 경과되어 토큰이 만료되어 발생합니다. 유효시간이 만료되었습니다.
처음부터 다시 시도해 주세요.
5034 요청한 ARS-CODE가 없거나 이용기관에 사용이 허가된 ARS코드가 아닐경우 발생합니다. 등록되지 않은 ARS-CODE입니다.
관리자에게 문의해 주세요
5037 요청한 ArsCode 기준 사용할 수 있는 SiteId 목록에 없을경우에 발생합니다. 해당 ARS Code를 사용할 수 없는 Site 입니다.
관리자에게 문의해 주세요
5101 서비스 이용시 인증요청을 시도한 클라이언트와 검증요청을 시도한 클라이언트의 정보가 변경되어 이상현상이 감지한 경우 발생합니다. 잘못된 요청이 감지되었습니다.
관리자에게 문의해 주세요.
6021 요청정보 중 통신사 인증용 트랜잭션ID 오류가 발생했습니다. 본인확인서비스 운영담당자에게 확인 바랍니다. 일시적인 오류입니다.
잠시 후 다시 시도해 주세요.
6022 요청정보 중 CPCODE 오류가 발생했습니다. 본인확인서비스 운영담당자에게 확인 바랍니다. 등록되지 않은 CPCODE 입니다.
관리자에게 문의해 주세요.
6023 요청정보 중 거래ID 중복요청으로 인하여 오류가 발생했습니다. 일시적인 오류입니다.
잠시 후 다시 시도해 주세요.
6024 요청정보 중 인증번호(OTP) 전송요청 3분 제한시간이 초과하여 오류가 발생했습니다. OTP 입력시간을 초과하였습니다. 잠시 후 다시 시도해 주세요.
6025 요청정보 중 CP SMS 미사용 설정 오류가 발생했습니다. 잘못된 요청입니다.
관리자에게 문의해 주세요.
6026 요청정보 중 Message형식 형식에서 오류가 발생했습니다. 잘못된 요청입니다.
관리자에게 문의해 주세요.
6027 요청정보 중 MMS 미사용 / CP사 정보 확인시 오류가 발생했습니다. 잘못된 요청입니다.
관리자에게 문의해 주세요.
6028 본인확인 처리시 원문 무결성 검증데이터 체크에서 오류가 발생했습니다. 본인확인서비스 운영담당자에게 확인 바랍니다. 일시적인 오류입니다.
잠시 후 다시 시도해 주세요. 지속적으로 오류가 발생하는 경우 관리자에게 문의해주세요.
6037 T인증 통신 실패 오류가 발생했습니다. 일시적인 오류입니다.
잠시 후 다시 시도해 주세요.
6038 T인증 통신 유효시간 초과 실패 오류가 발생했습니다. 유효시간이 만료되었습니다.
처음부터 다시 시도해 주세요.
6039 T인증 서버 작업등으로 인한 일시적 오류가 발생했습니다. PASS 서비스 점검중입니다.
잠시 후 다시 시도해 주세요.
6040 T인증 트랜잭션ID 요청실패로 인한 오류가 발생했습니다. 본인확인서비스 운영담당자에게 확인 바랍니다. 일시적인 오류입니다.
잠시 후 다시 시도해 주세요.
6041 T인증 KEY 처리로 인한 오류가 발생했습니다. 본인확인서비스 운영담당자에게 확인 바랍니다. 일시적인 오류입니다.
잠시 후 다시 시도해 주세요. 지속적으로 오류가 발생하는 경우 관리자에게 문의해주세요.
6042 T인증 서버에서 오류가 발생했습니다. 본인확인서비스 운영담당자에게 확인 바랍니다. 일시적인 오류입니다.
잠시 후 다시 시도해 주세요.
6050 SMS 전송 실패가 발생했습니다. SMS 메시지 전송 중 오류가 발생하였습니다.
잠시 후 다시 시도해 주세요.
6052 통신사 응답전송실패 실패가 발생했습니다. 본인확인서비스 운영담당자에게 확인 바랍니다. 일시적인 오류입니다.
잠시 후 다시 시도해 주세요.
6053 통신사 시스템 오류가 발생했습니다. 본인확인서비스 운영담당자에게 확인 바랍니다. 시스템 오류가 발생했습니다.
잠시 후 다시 시도해 주세요. 지속적으로 오류가 발생하는 경우 관리자에게 문의해주세요.
6054 통신사 통신 전문오류가 발생했습니다. 본인확인서비스 운영담당자에게 확인 바랍니다. 일시적인 오류입니다.
잠시 후 다시 시도해 주세요. 지속적으로 오류가 발생하는 경우 관리자에게 문의해주세요.
6081 통신사 통신시 통합실패 특이케이스가 발생했습니다. 본인확인서비스 운영담당자에게 확인 바랍니다. 일시적인 오류입니다.
잠시 후 다시 시도해 주세요. 지속적으로 오류가 발생하는 경우 관리자에게 문의해주세요.
6082 통신사 통신시 중복 전문 요청이 발생했습니다. 본인확인서비스 운영담당자에게 확인 바랍니다. 일시적인 오류입니다.
잠시 후 다시 시도해 주세요.
6092 LGU+ APP SMS 발송 실패가 발생했습니다. 일시적인 오류입니다.
잠시 후 다시 시도해 주세요.
6093 LGU+ APP SMS 발송 실패가 발생했습니다. 일시적인 오류입니다.
잠시 후 다시 시도해 주세요.
6094 통신사 통신시 전문 요청시 이슈가 발생했습니다. 본인확인서비스 운영담당자에게 확인 바랍니다. 일시적인 오류입니다.
잠시 후 다시 시도해 주세요. 지속적으로 오류가 발생하는 경우 관리자에게 문의해주세요.
6095 통신사 인증요청 서버 연동시 오류가 발생했습니다. 본인확인서비스 운영담당자에게 확인 바랍니다. 일시적인 오류입니다.
잠시 후 다시 시도해 주세요. 지속적으로 오류가 발생하는 경우 관리자에게 문의해주세요.
6096 통신사 개인정보 획득시 서버 오류가 발생하였습니다. 본인확인서비스 운영담당자에게 확인 바랍니다. 일시적인 오류입니다.
잠시 후 다시 시도해 주세요. 지속적으로 오류가 발생하는 경우 관리자에게 문의해주세요.
6097 SMS/LMS 발송 오류가 발생했습니다. 일시적인 오류입니다.
잠시 후 다시 시도해 주세요. 지속적으로 오류가 발생하는 경우 관리자에게 문의해주세요.
6098 통신사 서버에서 오류가 발생하였습니다. 본인확인서비스 운영담당자에게 확인 바랍니다. 일시적인 오류입니다.
잠시 후 다시 시도해 주세요. 지속적으로 오류가 발생하는 경우 관리자에게 문의해주세요.
6100 통신사 서버에서 신원확인 처리시 오류가 발생하였습니다. 본인확인서비스 운영담당자에게 확인 바랍니다. 일시적인 오류입니다.
잠시 후 다시 시도해 주세요. 지속적으로 오류가 발생하는 경우 관리자에게 문의해주세요.
6101 통신사 서버에서 오류가 발생하였습니다. 본인확인서비스 운영담당자에게 확인 바랍니다. 일시적인 오류입니다.
잠시 후 다시 시도해 주세요. 지속적으로 오류가 발생하는 경우 관리자에게 문의해주세요.
6102 통신사 시스템에서 오류가 발생하였습니다. 본인확인서비스 운영담당자에게 확인 바랍니다. 일시적인 오류입니다.
잠시 후 다시 시도해 주세요. 지속적으로 오류가 발생하는 경우 관리자에게 문의해주세요.
6118 인증실패 오류가 발생하였습니다. 본인확인서비스 운영담당자에게 확인 바랍니다. 일시적인 오류입니다.
잠시 후 다시 시도해 주세요.
6200 PASS 인증실패(유효하지 않은 APP Token) 오류가 발생했습니다. 일시적인 오류입니다.
잠시 후 다시 시도해 주세요.
6201 PASS 인증실패(유효하지 않은 Session ID) 오류가 발생했습니다. PASS인증에 실패하였습니다.
문자 (SMS) 인증으로 다시 시도해 주세요.
6204 PASS 인증실패(유효하지 않은 TID) 오류가 발생했습니다. 일시적인 오류입니다.
잠시 후 다시 시도해 주세요.
6206 PASS 트랜잭션 생성실패 오류가 발생했습니다. 일시적인 오류입니다.
잠시 후 다시 시도해 주세요.
6208 PASS 인증실패(민앤지 인증실패) 오류가 발생했습니다. PASS인증에 실패하였습니다.
잠시 후 다시 시도해 주세요. 지속적으로 오류가 발생하는 경우 관리자에게 문의해주세요.
6083 요청정보 중 서비스코드 형식에서 오류가 발생했습니다. 잘못된 요청입니다.
관리자에게 문의해 주세요.
6084 LGU+ 대행업체코드에서 오류 입력이 확인되었습니다. 본인확인서비스 운영담당자에게 확인 바랍니다. 잘못된 요청입니다.
관리자에게 문의해 주세요.
6085 요청정보 중 거래번호 입력값에서 오류가 발생했습니다. 잘못된 요청입니다.
관리자에게 문의해 주세요.
6086 요청정보 중 전화번호 입력값에서 오류가 발생했습니다. 잘못된 요청입니다.
관리자에게 문의해 주세요.
6087 요청정보 중 명의자 주민번호 입력값에서 오류가 발생했습니다. 잘못된 요청입니다.
관리자에게 문의해 주세요.
6088 요청정보 중 회원사 URL 미입력 오류가 발생했습니다. 본인확인서비스 운영담당자에게 확인 바랍니다. 잘못된 요청입니다.
관리자에게 문의해 주세요.
6089 요청정보 중 인증번호(OTP) 검증구분코드에서 오류가 발생했습니다. 본인확인서비스 운영담당자에게 확인 바랍니다. 잘못된 요청입니다.
관리자에게 문의해 주세요.
6090 요청정보 중 인증번호(OTPCode) 에서 오류가 발생했습니다. 잘못된 요청입니다.
관리자에게 문의해 주세요.
6091 요청정보 중 간편본인확인 인증 구분 코드에서 오류가 발생했습니다. 잘못된 요청입니다.
관리자에게 문의해 주세요.
6099 인증요청 및 검증요청시 시간초과로 인한 유효시간 만료 오류가 발생하였습니다. 유효시간이 만료되었습니다.
처음부터 다시 시도해 주세요.
6999 통신사 시스템 내부 오류가 발생하였습니다. 시스템 오류가 발생했습니다.
잠시 후 다시 시도해 주세요. 지속적으로 오류가 발생하는 경우 관리자에게 문의해주세요.
7001 본인확인 완료 후 검증토큰(keyToken)에 해당하는 결과정보를 찾을 수 없습니다. 검증토큰이 올바르지 않거나 검증요청 후 세션 유지시간인 7분을 초과하여 조회가 되지 않을때 발생 할 수 있습니다. 인증 요청 정보가 올바르지 않습니다(검증실패)
확인 후 다시 시도해 주세요.
8001 인증요청시 필수 요청 값인 이용기관ID(cpid)가 없습니다. 인증 요청 정보가 올바르지 않습니다(이용기관)
관리자에게 문의해 주세요.
8002 인증요청시 필수 요청 값인 응답결과 수신 URL(rtn_url) 정보가 없습니다. 인증 요청 정보가 올바르지 않습니다(return_url)
관리자에게 문의해 주세요.
8003 인증요청시 필수 요청 값인 요청 날짜, 요청번호등 필수 요청값(req_info) 이 없습니다. 인증 요청 정보가 올바르지 않습니다(요청정보)
관리자에게 문의해 주세요.
8004 본인확인 서비스에 등록되지 않은 이용기관 서비스 ID 입니다. 본인확인 담당자에게 문의하시기 바랍니다. 인증 요청 정보가 올바르지 않습니다(상품정보)
관리자에게 문의해 주세요.
8005 본인확인 서비스에 등록되지 않은 이용기관 ID 입니다. 본인확인 담당자에게 문의하시기 바랍니다. 인증 요청 정보가 올바르지 않습니다(이용기관)
관리자에게 문의해 주세요.
8006 본인확인 서비스에 등록되지 않은 이용기관 도메인 입니다. 본인확인 담당자에게 문의하시기 바랍니다. 인증 요청 정보가 올바르지 않습니다(이용기관)
관리자에게 문의해 주세요.
8007 본인확인 서비스에 등록되지 않은 이용기관 응답결과 수신 도메인(허가된 응답결과 수신 도메인) 입니다. 본인확인 담당자에게 문의하시기 바랍니다. 인증 요청 정보가 올바르지 않습니다(return_url)
관리자에게 문의해 주세요.
8101 본인확인 서비스 요청 응답 결과 복호화에 실패했습니다. 올바른 본인확인 복호화용 키가 설정되어 있는지 확인바랍니다. 인증 요청 정보가 올바르지 않습니다(요청정보 복호화)
관리자에게 문의해 주세요.
8102 본인확인 서비스 요청 정보 생성에 실패했습니다. 올바른 본인확인 암호화용 키가 설정되어 있는지 확인바랍니다. 인증 요청 정보가 올바르지 않습니다(요청정보 생성실패)
관리자에게 문의해 주세요.
8201 본인확인 서비스 응답결과 생성시 결과값 암호화에 실패했습니다. 본인확인 검증요청시 이름 등 길이제한을 초과하여 입력한 경우 발생할 수 있습니다. 인증 요청 정보가 올바르지 않습니다(결과값 암호화실패)
관리자에게 문의해 주세요.
9997 PASS등 인증 및 검증 재발송을 허용하지 않는 서비스 진행시 재발송을 요청한 경우 발생합니다. 재발송을 제공하지 않는 서비스입니다.
확인 후 다시 시도해 주세요.
기타코드 서비스 모듈에서 일반적이지 않은 오류가 발생했거나 통신사 응답값에 일반적이지 않은 오류가 발생한 경우 에러코드표에 없는 오류코드가 응답될 수 있습니다. 본인확인 담당자에게 문의하시기 바랍니다. 원인을 알 수 없는 오류가 발생했습니다. 잠시 후 다시 시도해 주세요
Back to top