[보안뉴스 원병철 기자] 개인정보 처리자가 개인정보를 안전하게 저장하고 전송하는 데 필요한 암호화와 관련된 안내서인 ‘개인정보의 암호화 조치 안내서’ 개정안이 최근 발표됐다. 이번 개정안은 2012년 10월에 발표한 안내서 이후 처음 개정돼 더욱 주목을 끌고 있다. 이에 본지는 예전 2012년 발표한 안내서와 최근 개정판을 비교해서 바뀌거나 추가된 내용을 살펴봤다.  

개인정보의 암호화 조치 안내서는 ‘개인정보보호법’에 따라 개인정보 처리자가 개인정보의 안전성 확보를 위해 이행해야 할 기술적 보호조치 중 ‘암호화’에 대한 안내서다. 개인정보처리자가 주민등록번호의 저장·전송시 필요한 암호화 수행방식과 사례 등을 소개하고 있다. 이번 안내서 개정 작업은 행정자치부와 함께 한국인터넷진흥원(KISA)에서 주도적으로 진행했다.  

이번 개정안은 개인정보처리자가 고유식별정보, 비밀번호, 바이오정보 등 암호화 대상 개인정보의 저장·전송 시 적용할 수 있는 암호 알고리즘, 수행방식, 사례 등을 제시하고 있으며, 제시된 암호 알고리즘 등은 2016년 9월 기준으로 작성된 것으로 알려졌다.  

단, 암호 알고리즘 등의 안전성은 시간이 경과하면서 변할 수 있으므로 권고하는 암호 알고리즘 등에 대해서는 국내·외 암호 관련 연구기관에서 제시하는 최신 정보를 확인할 것을 권고하고 있다. 또한, 안내서에서 제시하는 암호화 적용 사례는 개인정보 처리자별 개인정보 처리 시스템의 구성 및 운영 환경 등에 따라 적용방식이 달라질 수 있다고 덧붙였다. 

이번 개정안은 암호화의 종류와 근거 법률, 그리고 암호화 구현과 키 관리, 마지막으로 암호화 추진 절차와 사례에 대해 다루고 있으며, 추가로 암호화와 관련된 F&Q와 참고자료로 구성됐다. 전반적으로 개정안은 초기 안내서를 기본으로 내용이 추가되거나 바뀌었다. 

우선, ‘개인정보의 안전성 확보조치 기준’에 따라 개인정보를 ‘안전한 암호 알고리즘’으로 암호화하도록 되어 있는데, 개정안에서는 이를 공공기관과 민간부문(법인, 단체, 개인)으로 나뉘어 설명하고 있다. 

또한, 암호화 근거 법률을 보면, 개정안에서는 개인정보보호법 중 제23조(민감정보의 처리 제한)와 제24조의2(주민등록번호 처리의 제한)가 추가됐다. 이와 함께 개인정보 보호법 시행령 제21조와 제21의2도 추가됐다. 

암호화 구현 및 키 관리에서는 ‘업무용 컴퓨터·보조저장매체 암호화 방식’이 추가됐다. 업무용 컴퓨터에서 하드디스크, 이동식 디스크 또는 보조저장매체(USB 등)에 저장된 개인정보의 보호를 위해 문서 파일단위 암호화, 디렉터리 단위 암호화, 디스크 암호화 등의 방법을 사용할 수 있다고 설명하고 있다.  

또한, 암호키 관리 항목도 추가됐는데, 여기서는 암호키의 생성부터 운영과 정지, 마지막 폐기 단계까지 자세하게 안내하고 있다.  

마지막으로 암호화 추진 절차 및 사례에서는 보다 실질적인 예시가 추가됐다. 특히, 예시도 단순 나열이 아닌, 암호화 계획 수립에서부터 운영환경 분석과 비용 산정 방법 등이 구체적으로 제시되어 실질적인 ‘안내서’로서의 역할에 충실하고 있다. 특히, 부록으로 첨가된 FAQ는 실제 사용자들이 궁금해 하는 부분을 콕 짚어 설명하고 있어 소개한다. 

Q 1. 개인정보보호법 상의 암호화 대상은 무엇이며 어떻게 암호화해야 하나요?
개인정보보호법상 암호화 대상은 고유식별정보(주민등록번호, 외국인등록번호, 운전면허번호, 여권번호), 비밀번호, 바이오정보입니다. 암호화 대상 정보를 전송시 그리고 저장시 아래 표에 따라 암호화해야 합니다.

Q 2. 공공기관입니다. 개인정보처리시스템의 DBMS에서 제공하는 TDE 방식을 사용한 암호화가 개인정보보호법에 위배됩니까?
개인정보보호법 관점에서는 개인정보의 안전성 확보조치 기준(고시)에 따라 고유식별정보 암호화시 안전한 알고리즘을 사용하도록 하고 있습니다. TDE 방식에서 안전한 알고리즘을 사용하여 암호화한다면 법 위반사항이 아닙니다. 다만, 공공기관은 전자정부법에 따라 국가정보원이 안전성을 확인한 암호모듈 또는 제품을 우선 적용하여야 하며 자세한 사항은 해당 기관에 적용되는 관련 법령, 고시, 규정, 지침 등을 확인하시기 바랍니다. 

Q 3. 암호화 관련하여 우리 기관(공공, 민간)에 적용되는 규정·지침과 개인정보보호법에서 적용하는 암호화 요구사항이 서로 다를 때 어느 것을 적용해야 하나요?
개인정보보호법 및 시행령, 고시에서 규정한 암호화 요구사항을 준수하면 개인정보 보호법상 암호화 의무는 준수한 것입니다. 본 고시 준수로 인하여 다른 규정·지침을 준수하기 어렵게 된다면 '개인정보보호법'은 준수했으나 해당 규정·지침은 위배한 것이 될 수 있습니다.
따라서, 최선의 방법은 개인정보보호법과 해당 기관에 적용되는 규정·지침에서 요구하는 암호화 관련 사항 모두를 준수하는 것이라 할 수 있습니다.

Q 4. 안전한 암호 알고리즘에는 어떤 것들이 있나요?
안전한 암호 알고리즘은 국내·외 전문기관에서 권고하고 있는 알고리즘으로서 본 안내서의 ‘[참고 1] 국내·외 암호 연구 관련 기관의 권고 암호 알고리즘’, ‘[참고 2] 국가정보원 검증대상 암호 알고리즘 목록’의 내용을 참고하시기 바랍니다.

Q 5. 대칭키 암호 알고리즘 DES나 해쉬함수 MD5를 사용하면 안 됩니까?
DES와 MD5와 같은 암호 알고리즘의 경우 안전성 유지가 어려우므로 안전한 암호 알고리즘으로 볼 수 없어 권고하고 있지 않습니다. 안전한 암호 알고리즘은 본 안내서의 ‘[참고 1] 국내·외 암호 연구 관련 기관의 권고 암호 알고리즘’, ‘[참고 2] 국가정보원 검증대상 암호 알고리즘 목록’ 내용을 참고하시기 바랍니다.

Q 6. DB에 저장된 주민등록번호를 일부분만 암호화해서 저장해도 되는 것인지요?
예, 일부분 암호화가 가능합니다. 시스템 운영이나 개인 식별을 위해 해당 정보를 활용해야 하는 경우 생년월일 및 성별을 포함한 앞 7자리를 제외하고 뒷자리 6개 번호를 암호화 하여 사용할 수도 있습니다.

Q 7. 암호화해야 하는 바이오정보의 대상은 어디까지인지요?
암호화해야 하는 바이오정보는 식별 및 인증 등의 업무절차상 수집이 명확한 경우로 한정되며, 이와 무관하게 수집되는 이미지, 녹취 정보 등은 암호화 대상에서 제외됩니다. 예를 들어, 콜센터 등에서 업무절차상 주민등록번호 수집이 명확한 경우의 음성기록은 암호화해야 하나, 단순 상담 시 저장되는 음성기록 등은 암호화 대상에서 제외될 수 있습니다.

Q 8. 안전한 대칭키 암호화 알고리즘 사용시 암호키(비밀키)의 길이는 어떻게 설정해야 하나요?
암호키의 길이가 짧거나 사용되는 문자의 종류를 섞어 쓰지 않으면 암호화가 되었더라도 공격자가 쉽게 암호 해독을 할 수 있습니다. 암호해독이 어렵도록 암호키 설정시 문자, 숫자, 특수문자 등의 문자조합 방법과 문자열 길이, 사용기간 등의 암호키 작성 규칙을 정하여 운영하는 것이 바람직합니다. 특히, 잘 알려진 영문자, 숫자(1234, 123456, love, happy, admin, admin1234) 등은 쉽게 유추 할 수 있으므로 사용하지 않도록 주의해야 합니다.

Q 9. 회사에 고객들의 이름, 주소, 전화번호, 이메일, 비밀번호를 저장하고 있습니다. 암호화 대상이 무엇인가요?
개인정보의 안전성 확보조치 기준 고시에서 암호화 대상은 고유식별정보(주민등록번호, 여권번호, 운전면허번호, 외국인등록번호), 비밀번호, 바이오정보입니다. 특히, 비밀번호의 경우에는 일방향(해쉬) 암호화하여 저장하시면 됩니다.

Q 10. 부동산중개업을 하고 있습니다. 업무용 컴퓨터에 한글, 엑셀을 이용하여 주민등록번호를 처리하고 있습니다. 암호화를 어떻게 해야 합니까?
PC에 저장된 개인정보의 경우 상용프로그램(한글, 엑셀 등)에서 제공하는 비밀번호 설정기능을 사용하여 암호화를 적용하거나 안전한 암호화 알고리즘을 이용하는 소프트웨어를 사용하여 암호화할 수 있습니다.
※ 한컴 오피스 : 파일 >> 다른이름으로 저장하기 >> 문서 암호 설정에서 암호 설정 가능
※ MS 오피스 : 파일 >> 다른이름으로 저장하기 >> 도구 >> 일반옵션에서 암호 설정 가능

Q 11. A사가 개인정보처리 시스템을 위탁하거나, ASP, 클라우드 서비스를 이용하는 경우 암호화 수행을 누가 해야 하나요?
개인정보의 암호화 등 안전성 확보조치는 원칙적으로 ‘개인정보처리자’의 의무입니다. 따라서 개인정보처리 시스템을 위탁하거나 ASP를 이용하는 경우에도 암호화 조치사항에 대한 이행여부에 대한 책임은 위탁기관인 A사가 지게 됩니다. 다만, A사는 암호화에 대한 요구사항을 A사의 위탁을 받은 수탁기관(ASP, 클라우드 서비스 제공자 등)과의 계약서 등에 명시하여 수탁기관으로 하여금 암호화를 처리하게 요구할 수 있습니다.

이번 개인정보의 암호화 조치 안내서 개정안은 약 5년 만에 나온 개정안으로 그동안 바뀐 법률이나 시행령, 최신 암호화 기술 등을 잘 짚어서 안내하고 있다. 다만 일부 항목의 설명이나 사례가 그대로 사용된 부분이나 예시에 사용된 사진의 해상도가 낮아 가독성이 떨어지는 부분은 개선되어야 할 것으로 보인다.

한편, 이번에 발표된 ‘개인정보의 암호화 조치 안내서’ 개정안은 본지 컨텐츠 코너나 개인정보보호 종합지원 포털(www.privacy.go.kr)에서 다운로드 받을 수 있다. 

출처 : boannews.com 보안뉴스
[원병철 기자(boanone@boannews.com)]

-- 분석 함수

    -- RANK OVER()

    -- ROW_NUMBER() OVER() ** 중요  제일 많은 씀 **

      -- 순위를 구함. 

      -- RANK() OVER()는 동일 순위인 경우 1,1,3, 형식으로 출력하지만

      -- ROW_NUMBER() OVER()는 동일 순위인 경우 1,2,3, 형식으로 출력

      -- DENSE_RANK() OVER()는 동일 순위인 경우 1,1,2 형식으로 출력

      -- ROW_NUMBER() OVER()는 매우매우매우 중요한 함수이므로 반드시 알아 둘것 !!!!!!!!!!!!!!!!!!!!!!!

      --기본급 내림차순으로 순위를 구하기

      SELECT name, basicpay, RANK() OVER(ORDER BY basicpay DESC) 순위 FROM insa; -- 비교데이타가 똑같으면 순위를 건너뜀

      SELECT name, basicpay, ROW_NUMBER() OVER(ORDER BY basicpay DESC) 순위 FROM insa; -- 비교데이타가 똑같아도 순위를 차례대로 매김

      -- 기본급 내림차순으로 순위. 단, 기본급이 같으면 수당 내림차순.

      SELECT name, basicpay, sudang, RANK() OVER(ORDER BY basicpay DESC, sudang DESC) 순위 FROM insa;

       SELECT name, basicpay, sudang, ROW_NUMBER() OVER(ORDER BY basicpay DESC, sudang DESC) 순위 FROM insa;

      -- 부서별 기본급의 내림차순 순위 구하기

      SELECT name, basicpay, buseo, 

        RANK() OVER(PARTITION BY buseo ORDER BY basicpay DESC, sudang DESC) 순위 

        FROM insa;

      SELECT name, basicpay, buseo, 

        ROW_NUMBER() OVER(PARTITION BY buseo ORDER BY basicpay DESC, sudang DESC) 순위 

        FROM insa;

      -- 출신도별 부서별 순위(학년의 반별)

      SELECT name, basicpay, city, buseo, 

        RANK() OVER(PARTITION BY city ORDER BY basicpay DESC, sudang DESC) 순위 

        FROM insa;

      -- 여자 인원수가 가장 많은 부서는?

      SELECT buseo, COUNT(*) FROM insa

        WHERE SUBSTR(ssn,8,1) IN (2,4,6)

        GROUP BY buseo;

      SELECT buseo FROM(

      SELECT buseo, COUNT(*) cnt, RANK() OVER(ORDER BY COUNT(*) DESC) 순위

        FROM insa WHERE SUBSTR(ssn,8,1) IN (2,4,6) GROUP BY buseo

        ) WHERE 순위 =1;

      -- 기본급여 많이 받는 1~10등 까지 출력(name, basicpay)

      SELECT name, basicpay,RANK() OVER(ORDER BY basicpay DESC) 순위 FROM(

      SELECT name, basicpay, RANK() OVER(ORDER BY basicpay DESC) 순위 FROM insa 

      ) WHERE 순위 <=10;

      -- 기본급 상위 10% 출력(name, basicpay)

       SELECT name, basicpay FROM(

        SELECT name, basicpay, RANK() OVER(ORDER BY basicpay DESC) 순위 FROM insa 

        )WHERE 순위<=TRUNC((SELECT COUNT(*) FROM insa) *0.1);

      -- 기본급 하위 10% 출력(

      SELECT name, basicpay FROM(

        SELECT name, basicpay, RANK() OVER(ORDER BY basicpay) 순위 FROM insa 

        )WHERE 순위<=TRUNC((SELECT COUNT(*) FROM insa) *0.1);

      -- 부서별 기본급여 가장 높은 사람들 출력( name, buseo, jikwi)

      SELECT name, buseo,basicpay, RANK() OVER(PARTITION BY buseo ORDER BY basicpay DESC) 순위

      FROM insa; -- 일단 부서별 순위를 매기는 쿼리

      SELECT name, buseo,basicpay FROM(

        SELECT name, buseo,basicpay,

        RANK() OVER(PARTITION BY buseo ORDER BY basicpay DESC) 순위 

        FROM insa

        ) WHERE 순위=1;

    -- ***** 나중에 게시판 작성 할 때 사용하는 쿼리 형식이므로 반드 암기 해야함. *****

    -- ROW_NUMBER()를 이용한 쿼리가 아래 ROWNUM을 사용한 쿼리보다 우수

      SELECT num,name,basicpay FROM(

        SELECT num, name, basicpay, ROW_NUMBER() OVER(ORDER BY num DESC) rnum FROM insa

        ) WHERE rnum>= 10 AND rnum <=15 ORDER BY num DESC;

     SELECT num,name,basicpay FROM(

      SELECT ROWNUM rnum, num, name, basicpay FROM(

        SELECT num, name, basicpay FROM insa ORDER BY num DESC

      )

    )WHERE rnum>=10 AND rnum<=15;

출처: http://tibang.tistory.com/entry/오라클-분석-함수-RANK-OVER-ROWNUMBER-OVER [T없이맑은날]

국내 망분리 관련 현황

1, 망분리 관련법

1) 관련법

망분리 관련 법은 , ‘정보통신망법’ 및 ‘개인정보보호법’, 금융위원회의 ‘금융전산 망분리 가이드라인’에 따름

• 정보통신망 이용촉진 및 정보보호 등에 관한 법률 시행령 제 15조 2항 3호(2013년 2월 18일 시행)
• 개인정보 보호법 시행령 제 30조 1항 2호

[정보통신망 이용촉진 및 정보보호 등에 관련 법률 시행령]

[개인정보 보호법 시행령 제 30조 1항 2호]

2) 망분리 대상

정보통신망법 시행령에 따르면,전년도말 직전 3개월간 일일평균 100만명 이상의 이용자 개인정보를 보유하거나 전년도 정보통신분야매출액이 100억원 이상인 정보통신서비스 제공자는 개인정보처리시스템에 접속하는 컴퓨터 등을 외부 인터넷망과 차단해야 함

[망분리 대상]

개인정보의 단순 열람, 수정 권한만을 가진 개인정보취급자는 의무 대상은 아니지만, 개인정보의 유노출에 대해 엄격히 제한해야함

3) 금융권 망분리 가이드라인

2. 망분리 관련 솔루션 현황

1) 망분리 구축 방식(3가지)

[방식별 비교]

$ tar cvf - * | ssh root@[Target IPAddress] tar xf - -C [Target Directory]

출처 : http://zero-gravity.tistory.com/221

OTP 기능을 구현하라는 미션이 떨어졌고, 힌트로는 구글OTP라는 것이 있다라는 것만 받았다.

   찾아보니 거의 다 "Google Authenticator"라는 앱을 다운받아서 구글 로그인을 할 때에 이용하는 내용이었다.

   뭔가 구글에서 제공하는 API가 있어야 구글앱을 이용해서 개발을 할 수 있을 텐데, 눈을 씻고 찾아봐도 API는 없었다.

   찾다찾다 구글앱의 공식 홈페이지에서 파일들을 다운로드 할 수 있는 곳을 찾았는데, C언어로 되어있고 내가 원하는 것은 아니었다. 아마도 SSH로 접속해서 이걸 설치하고 로그인을 할 때에 사용하는 그런 종류인 듯 싶다.(이곳 참고)

   알고리즘을 중심으로 찾아본 결과, 아마도 IETF에 있는 RFC6238이라는 문서를 기반으로 구글앱이 이와 같은 알고리즘으로 구현을 해놓은 것 같다.

   따져보니 이것과 똑같은 알고리즘으로 Key/바코드를 만들어내고 그것을 검증하는 코드를 짜면 완벽하게 구글앱을 사용하는 OTP 기능을 만들어낼 수 있을 것 같았다.

   다른 사람들이 만들어놓은 자바 코드를 찾지 못했을 경우, 최악의 경우엔 정말 그렇게 해보려고 했다.

   국내에선 파이썬 코드를 쉽게 찾을 수 있었지만 자바가 아니어서 아무 쓸모가 없었다.

   지푸라기라도 잡는 심정으로 온갖 검색어 조합을 동원하여 외국 사이트를 이 잡듯이 뒤진 결과,

   다행히 누군가 자바스크립트로 구현해놓은 코드를 발견했다.

   미칠듯이 기뻤다. 속으로 감동의 눈물을 흘릴 정도였다. 그러나 의존하는 라이브러리 파일들을 제대로 다 링크해주고, 코드도 이대로 했음에도 불구하고 어떤 연유에서인지 내가 테스트하는 프로젝트에서는 작동하지 않았다. 

   이내 포기하고 다른 코드를 찾아 헤맸는데, 정말 다행스럽게도 자바로 구현한 코드를 찾았냈다!!!

   그런데 이것도 코드에서 sercretSize, numOfScratchCodes, scratchCodeSize를 몇으로 설정해줘야 하는지 별 말도 없고 그닥 친절하지 않아서 적용에 실패했다.

   더 찾아보니 이 코드를 기반으로 복잡하게 만들어놓은 코드를 발견했는데, 이건 더 머리가 터질 것 같았다. 하루 반 동안 붙잡고 하다가 GG.

   결국 다시 간단한 자바 코드로 돌아가서 붙잡고 요리조리 해본 결과, 성공!!!!

   서론이 길었다.;;

   아무튼 총 4일 동안 끙끙대서 성공한 결과물을 아래에 설명하고자 한다. 비록 내가 처음부터 날코딩한 것은 아니지만, OTP를 구현하려 나처럼 인터넷 망망대해를 떠돌고 있을 불쌍한 중생들을 위해 올려놓는다.

   먼저 OTP란 무엇이고 어떻게 돌아가는지부터 알고 들어가야 하니 간단하게 짚고 넘어가겠다.

   1. OTP란?

   One Time Password의 약자로, 우리말로 하면 일회용 비밀번호라 할 수 있다. 일회성이라는 특징 때문에 일반 비밀번호 입력이나 공인인증서 이용보다도 더 안전한 방법으로 알려져있다. 주로 금융권이나 일반 웹사이트 2차 로그인 인증으로 많이 활용되고 있다. OTP의 종류에는 원리에 따라 S/KEY방식, 시간 동기화 방식, 챌린지 응답 방식, 이벤트 동기화 방식 등이 있다. (좀더 자세한 내용을 알고 싶다면, 위키백과 참조) 여기서는 이중 시간 동기화 방식을 사용한 Google Authenticator라는 앱으로 TOTP 인증을 구현해보도록 하겠다.

   2. TOTP((Time-based One Time Password)의 원리

   많은 사람들이 오해하는 게 있는데(나 또한 그랬다), OTP 기기와 서버가 통신하는 줄 착각한다. 실상은 그렇지 않다. OTP 기기와 서버는 모두 같은 알고리즘을 바탕으로 하기 때문에 통신이 필요치 않다. 원리는 간단하다. 서버쪽에서 해당 알고리즘으로 Key나 바코드 주소를 생성해주면 그걸 OTP 기기에 입력해준다. 그러면 기기에서는 그 Key나 바코드를 기준으로 하여 30~60초 마다 계속하여 새로운 일회용 비밀번호를 생성해낸다. 그 일회용 비밀번호를 입력하여 서버로 전송하면 서버에서 그 비밀번호가 맞는지 알고리즘으로 확인하는 방식이다. 여기서 구글앱을 이용한다는 것은 OTP 기기 대신에 스마트폰에 있는 Google Authenticator라는 앱으로 대체한다는 것이다.

   뭔가 복잡해보이지만, 이해하고나면 쉽다.

   3. Java로 구현해보기.

   자 그럼 Java로 직접해보자. 아래는 JSP를 이용해서 웹사이트에 구현하다는 가정 하에 진행하였다.

   먼저 commons-codec.jar 파일을 라이브러리에 추가해준다.

 commons-codec-1.9.jar

   또 만약 자바 버전이 1.6 이하일 경우에는 아래의 파일을 다운받아서 라이브러리 추가해준다.

 security.jar

   그리고 자신의 스마트폰에 Google Authenticator 앱을 다운받아 설치해놓는다.

   다음은 실제 코드다.

   2차 인증 로그인 리퀘스트가 들어올 시, 사용자명과 계정명을 받아서 키를 생성할 부분.

   otpTest.jsp

   키나 바코드를 이용해 구글앱에서 항목을 추가한 뒤, 거기서 생성되는 일회용 비밀번호를 code 부분에 써주고 전송을 클릭한다.

   code 부분에 저 숫자를 넣어주면 된다.

   전송 리퀘스트를 받는 부분에서 해당 코드가 맞는지 여부를 검사한다.

   시간이 흘러서 일회용 비밀번호가 계속 바뀌어도 바뀐 일회용 비밀번호를 입력하면 완벽하게 true를 뱉어냄을 확인할 수 있다.

   지금까지 구글앱을 이용한 OTP 기능을 어떻게 구현하는지 알아봤다.

   사실 구글앱을 이용하는 방법 말고도 오픈소스를 이용한다든지, 돈으로 떼우는 방법 등등..  방법은 많다.

   아무쪼록 구글앱을 이용한 OTP 기능 개발을 찾아헤매는 사람들에게 도움이 되었길 바란다.

INFORMATIONAL
Errata Exist

Internet Engineering Task Force (IETF)                        D. M'Raihi
Request for Comments: 6238                                Verisign, Inc.
Category: Informational                                       S. Machani
ISSN: 2070-1721                                         Diversinet Corp.
                                                                  M. Pei
                                                                Symantec
                                                               J. Rydell
                                                          Portwise, Inc.
                                                                May 2011


              
TOTP: Time-Based One-Time Password Algorithm

Abstract

   This document describes an extension of the One-Time Password (OTP)
   algorithm, namely the HMAC-based One-Time Password (HOTP) algorithm,
   as defined in RFC 4226, to support the time-based moving factor.  The
   HOTP algorithm specifies an event-based OTP algorithm, where the
   moving factor is an event counter.  The present work bases the moving
   factor on a time value.  A time-based variant of the OTP algorithm
   provides short-lived OTP values, which are desirable for enhanced
   security.

   The proposed algorithm can be used across a wide range of network
   applications, from remote Virtual Private Network (VPN) access and
   Wi-Fi network logon to transaction-oriented Web applications.  The
   authors believe that a common and shared algorithm will facilitate
   adoption of two-factor authentication on the Internet by enabling
   interoperability across commercial and open-source implementations.

Status of This Memo

   This document is not an Internet Standards Track specification; it is
   published for informational purposes.

   This document is a product of the Internet Engineering Task Force
   (IETF).  It represents the consensus of the IETF community.  It has
   received public review and has been approved for publication by the
   Internet Engineering Steering Group (IESG).  Not all documents
   approved by the IESG are a candidate for any level of Internet
   Standard; see Section 2 of RFC 5741.

   Information about the current status of this document, any errata,
   and how to provide feedback on it may be obtained at
   http://www.rfc-editor.org/info/rfc6238.





M'Raihi, et al.               Informational                     [Page 1]

 
RFC 6238                      HOTPTimeBased                     May 2011


Copyright Notice

   Copyright (c) 2011 IETF Trust and the persons identified as the
   document authors.  All rights reserved.

   This document is subject to BCP 78 and the IETF Trust's Legal
   Provisions Relating to IETF Documents
   (http://trustee.ietf.org/license-info) in effect on the date of
   publication of this document.  Please review these documents
   carefully, as they describe your rights and restrictions with respect
   to this document.  Code Components extracted from this document must
   include Simplified BSD License text as described in Section 4.e of
   the Trust Legal Provisions and are provided without warranty as
   described in the Simplified BSD License.

Table of Contents

   1. Introduction ....................................................2
      1.1. Scope ......................................................2
      1.2. Background .................................................3
   2. Notation and Terminology ........................................3
   3. Algorithm Requirements ..........................................3
   4. TOTP Algorithm ..................................................4
      4.1. Notations ..................................................4
      4.2. Description ................................................4
   5. Security Considerations .........................................5
      5.1. General ....................................................5
      5.2. Validation and Time-Step Size ..............................6
   6. Resynchronization ...............................................7
   7. Acknowledgements ................................................7
   8. References ......................................................8
      8.1. Normative References .......................................8
      8.2. Informative References .....................................8
   Appendix A. TOTP Algorithm: Reference Implementation ...............9
   Appendix B. Test Vectors ..........................................14

.  Introduction

1.1.  Scope

   This document describes an extension of the One-Time Password (OTP)
   algorithm, namely the HMAC-based One-Time Password (HOTP) algorithm,
   as defined in [RFC4226], to support the time-based moving factor.








M'Raihi, et al.               Informational                     [Page 2]

 
RFC 6238                      HOTPTimeBased                     May 2011


1.2.  Background

   As defined in [RFC4226], the HOTP algorithm is based on the
   HMAC-SHA-1 algorithm (as specified in [RFC2104]) and applied to an
   increasing counter value representing the message in the HMAC
   computation.

   Basically, the output of the HMAC-SHA-1 calculation is truncated to
   obtain user-friendly values:

      HOTP(K,C) = Truncate(HMAC-SHA-1(K,C))

   where Truncate represents the function that can convert an HMAC-SHA-1
   value into an HOTP value.  K and C represent the shared secret and
   counter value; see [RFC4226] for detailed definitions.

   TOTP is the time-based variant of this algorithm, where a value T,
   derived from a time reference and a time step, replaces the counter C
   in the HOTP computation.

   TOTP implementations MAY use HMAC-SHA-256 or HMAC-SHA-512 functions,
   based on SHA-256 or SHA-512 [SHA2] hash functions, instead of the
   HMAC-SHA-1 function that has been specified for the HOTP computation
   in [RFC4226].

.  Notation and Terminology

   The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT",
   "SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY", and "OPTIONAL" in this
   document are to be interpreted as described in [RFC2119].

.  Algorithm Requirements

   This section summarizes the requirements taken into account for
   designing the TOTP algorithm.

   R1: The prover (e.g., token, soft token) and verifier (authentication
       or validation server) MUST know or be able to derive the current
       Unix time (i.e., the number of seconds elapsed since midnight UTC
       of January 1, 1970) for OTP generation.  See [UT] for a more
       detailed definition of the commonly known "Unix time".  The
       precision of the time used by the prover affects how often the
       clock synchronization should be done; see Section 6.

   R2: The prover and verifier MUST either share the same secret or the
       knowledge of a secret transformation to generate a shared secret.

   R3: The algorithm MUST use HOTP [RFC4226] as a key building block.



M'Raihi, et al.               Informational                     [Page 3]

 
RFC 6238                      HOTPTimeBased                     May 2011


   R4: The prover and verifier MUST use the same time-step value X.

   R5: There MUST be a unique secret (key) for each prover.

   R6: The keys SHOULD be randomly generated or derived using key
       derivation algorithms.

   R7: The keys MAY be stored in a tamper-resistant device and SHOULD be
       protected against unauthorized access and usage.

.  TOTP Algorithm

   This variant of the HOTP algorithm specifies the calculation of a
   one-time password value, based on a representation of the counter as
   a time factor.

4.1.  Notations

   o  X represents the time step in seconds (default value X =
      30 seconds) and is a system parameter.

   o  T0 is the Unix time to start counting time steps (default value is
      0, i.e., the Unix epoch) and is also a system parameter.

4.2.  Description

   Basically, we define TOTP as TOTP = HOTP(K, T), where T is an integer
   and represents the number of time steps between the initial counter
   time T0 and the current Unix time.

   More specifically, T = (Current Unix time - T0) / X, where the
   default floor function is used in the computation.

   For example, with T0 = 0 and Time Step X = 30, T = 1 if the current
   Unix time is 59 seconds, and T = 2 if the current Unix time is
   60 seconds.

   The implementation of this algorithm MUST support a time value T
   larger than a 32-bit integer when it is beyond the year 2038.  The
   value of the system parameters X and T0 are pre-established during
   the provisioning process and communicated between a prover and
   verifier as part of the provisioning step.  The provisioning flow is
   out of scope of this document; refer to [RFC6030] for such
   provisioning container specifications.







M'Raihi, et al.               Informational                     [Page 4]

 
RFC 6238                      HOTPTimeBased                     May 2011


.  Security Considerations

5.1.  General

   The security and strength of this algorithm depend on the properties
   of the underlying building block HOTP, which is a construction based
   on HMAC [RFC2104] using SHA-1 as the hash function.

   The conclusion of the security analysis detailed in [RFC4226] is
   that, for all practical purposes, the outputs of the dynamic
   truncation on distinct inputs are uniformly and independently
   distributed strings.

   The analysis demonstrates that the best possible attack against the
   HOTP function is the brute force attack.

   As indicated in the algorithm requirement section, keys SHOULD be
   chosen at random or using a cryptographically strong pseudorandom
   generator properly seeded with a random value.

   Keys SHOULD be of the length of the HMAC output to facilitate
   interoperability.

   We RECOMMEND following the recommendations in [RFC4086] for all
   pseudorandom and random number generations.  The pseudorandom numbers
   used for generating the keys SHOULD successfully pass the randomness
   test specified in [CN], or a similar well-recognized test.

   All the communications SHOULD take place over a secure channel, e.g.,
   Secure Socket Layer/Transport Layer Security (SSL/TLS) [RFC5246] or
   IPsec connections [RFC4301].

   We also RECOMMEND storing the keys securely in the validation system,
   and, more specifically, encrypting them using tamper-resistant
   hardware encryption and exposing them only when required: for
   example, the key is decrypted when needed to verify an OTP value, and
   re-encrypted immediately to limit exposure in the RAM to a short
   period of time.

   The key store MUST be in a secure area, to avoid, as much as
   possible, direct attack on the validation system and secrets
   database.  Particularly, access to the key material should be limited
   to programs and processes required by the validation system only.








M'Raihi, et al.               Informational                     [Page 5]

 
RFC 6238                      HOTPTimeBased                     May 2011


5.2.  Validation and Time-Step Size

   An OTP generated within the same time step will be the same.  When an
   OTP is received at a validation system, it doesn't know a client's
   exact timestamp when an OTP was generated.  The validation system may
   typically use the timestamp when an OTP is received for OTP
   comparison.  Due to network latency, the gap (as measured by T, that
   is, the number of time steps since T0) between the time that the OTP
   was generated and the time that the OTP arrives at the receiving
   system may be large.  The receiving time at the validation system and
   the actual OTP generation may not fall within the same time-step
   window that produced the same OTP.  When an OTP is generated at the
   end of a time-step window, the receiving time most likely falls into
   the next time-step window.  A validation system SHOULD typically set
   a policy for an acceptable OTP transmission delay window for
   validation.  The validation system should compare OTPs not only with
   the receiving timestamp but also the past timestamps that are within
   the transmission delay.  A larger acceptable delay window would
   expose a larger window for attacks.  We RECOMMEND that at most one
   time step is allowed as the network delay.

   The time-step size has an impact on both security and usability.  A
   larger time-step size means a larger validity window for an OTP to be
   accepted by a validation system.  There are implications for using a
   larger time-step size, as follows:

   First, a larger time-step size exposes a larger window to attack.
   When an OTP is generated and exposed to a third party before it is
   consumed, the third party can consume the OTP within the time-step
   window.

   We RECOMMEND a default time-step size of 30 seconds.  This default
   value of 30 seconds is selected as a balance between security and
   usability.

   Second, the next different OTP must be generated in the next time-
   step window.  A user must wait until the clock moves to the next
   time-step window from the last submission.  The waiting time may not
   be exactly the length of the time step, depending on when the last
   OTP was generated.  For example, if the last OTP was generated at the
   halfway point in a time-step window, the waiting time for the next
   OTP is half the length of the time step.  In general, a larger time-
   step window means a longer waiting time for a user to get the next
   valid OTP after the last successful OTP validation.  A too-large
   window (for example, 10 minutes) most probably won't be suitable for
   typical Internet login use cases; a user may not be able to get the
   next OTP within 10 minutes and therefore will have to re-login to the
   same site in 10 minutes.



M'Raihi, et al.               Informational                     [Page 6]

 
RFC 6238                      HOTPTimeBased                     May 2011


   Note that a prover may send the same OTP inside a given time-step
   window multiple times to a verifier.  The verifier MUST NOT accept
   the second attempt of the OTP after the successful validation has
   been issued for the first OTP, which ensures one-time only use of an
   OTP.

.  Resynchronization

   Because of possible clock drifts between a client and a validation
   server, we RECOMMEND that the validator be set with a specific limit
   to the number of time steps a prover can be "out of synch" before
   being rejected.

   This limit can be set both forward and backward from the calculated
   time step on receipt of the OTP value.  If the time step is
   30 seconds as recommended, and the validator is set to only accept
   two time steps backward, then the maximum elapsed time drift would be
   around 89 seconds, i.e., 29 seconds in the calculated time step and
   60 seconds for two backward time steps.

   This would mean the validator could perform a validation against the
   current time and then two further validations for each backward step
   (for a total of 3 validations).  Upon successful validation, the
   validation server can record the detected clock drift for the token
   in terms of the number of time steps.  When a new OTP is received
   after this step, the validator can validate the OTP with the current
   timestamp adjusted with the recorded number of time-step clock drifts
   for the token.

   Also, it is important to note that the longer a prover has not sent
   an OTP to a validation system, the longer (potentially) the
   accumulated clock drift between the prover and the verifier.  In such
   cases, the automatic resynchronization described above may not work
   if the drift exceeds the allowed threshold.  Additional
   authentication measures should be used to safely authenticate the
   prover and explicitly resynchronize the clock drift between the
   prover and the validator.

.  Acknowledgements

   The authors of this document would like to thank the following people
   for their contributions and support to make this a better
   specification: Hannes Tschofenig, Jonathan Tuliani, David Dix,
   Siddharth Bajaj, Stu Veath, Shuh Chang, Oanh Hoang, John Huang, and
   Siddhartha Mohapatra.






M'Raihi, et al.               Informational                     [Page 7]

 
RFC 6238                      HOTPTimeBased                     May 2011


.  References

8.1.  Normative References

   [RFC2104]  Krawczyk, H., Bellare, M., and R. Canetti, "HMAC: Keyed-
              Hashing for Message Authentication", RFC 2104,
              February 1997.

   [RFC2119]  Bradner, S., "Key words for use in RFCs to Indicate
              Requirement Levels", BCP 14, RFC 2119, March 1997.

   [RFC4086]  Eastlake 3rd, D., Schiller, J., and S. Crocker,
              "Randomness Recommendations for Security", BCP 106,
              RFC 4086, June 2005.

   [RFC4226]  M'Raihi, D., Bellare, M., Hoornaert, F., Naccache, D., and
              O. Ranen, "HOTP: An HMAC-Based One-Time Password
              Algorithm", RFC 4226, December 2005.

   [SHA2]     NIST, "FIPS PUB 180-3: Secure Hash Standard (SHS)",
              October 2008, <http://csrc.nist.gov/publications/fips/
              fips180-3/fips180-3_final.pdf>.

8.2.  Informative References

   [CN]       Coron, J. and D. Naccache, "An Accurate Evaluation of
              Maurer's Universal Test", LNCS 1556, February 1999,
              <http://www.gemplus.com/smart/rd/publications/pdf/
              CN99maur.pdf>.

   [RFC4301]  Kent, S. and K. Seo, "Security Architecture for the
              Internet Protocol", RFC 4301, December 2005.

   [RFC5246]  Dierks, T. and E. Rescorla, "The Transport Layer Security
              (TLS) Protocol Version 1.2", RFC 5246, August 2008.

   [RFC6030]  Hoyer, P., Pei, M., and S. Machani, "Portable Symmetric
              Key Container (PSKC)", RFC 6030, October 2010.

   [UT]       Wikipedia, "Unix time", February 2011,
              <http://en.wikipedia.org/wiki/Unix_time>.










M'Raihi, et al.               Informational                     [Page 8]

 
RFC 6238                      HOTPTimeBased                     May 2011


Appendix A.  TOTP Algorithm: Reference Implementation

 <CODE BEGINS>

 /**
 Copyright (c) 2011 IETF Trust and the persons identified as
 authors of the code. All rights reserved.

 Redistribution and use in source and binary forms, with or without
 modification, is permitted pursuant to, and subject to the license
 terms contained in, the Simplified BSD License set forth in Section
 4.c of the IETF Trust's Legal Provisions Relating to IETF Documents
 (http://trustee.ietf.org/license-info).
 */

 import java.lang.reflect.UndeclaredThrowableException;
 import java.security.GeneralSecurityException;
 import java.text.DateFormat;
 import java.text.SimpleDateFormat;
 import java.util.Date;
 import javax.crypto.Mac;
 import javax.crypto.spec.SecretKeySpec;
 import java.math.BigInteger;
 import java.util.TimeZone;


 /**
  * This is an example implementation of the OATH
  * TOTP algorithm.
  * Visit www.openauthentication.org for more information.
  *
  * @author Johan Rydell, PortWise, Inc.
  */

 public class TOTP {

     private TOTP() {}

     /**
      * This method uses the JCE to provide the crypto algorithm.
      * HMAC computes a Hashed Message Authentication Code with the
      * crypto hash algorithm as a parameter.
      *
      * @param crypto: the crypto algorithm (HmacSHA1, HmacSHA256,
      *                             HmacSHA512)
      * @param keyBytes: the bytes to use for the HMAC key
      * @param text: the message or text to be authenticated
      */



M'Raihi, et al.               Informational                     [Page 9]

 
RFC 6238                      HOTPTimeBased                     May 2011


     private static byte[] hmac_sha(String crypto, byte[] keyBytes,
             byte[] text){
         try {
             Mac hmac;
             hmac = Mac.getInstance(crypto);
             SecretKeySpec macKey =
                 new SecretKeySpec(keyBytes, "RAW");
             hmac.init(macKey);
             return hmac.doFinal(text);
         } catch (GeneralSecurityException gse) {
             throw new UndeclaredThrowableException(gse);
         }
     }


     /**
      * This method converts a HEX string to Byte[]
      *
      * @param hex: the HEX string
      *
      * @return: a byte array
      */

     private static byte[] hexStr2Bytes(String hex){
         // Adding one byte to get the right conversion
         // Values starting with "0" can be converted
         byte[] bArray = new BigInteger("10" + hex,16).toByteArray();

         // Copy all the REAL bytes, not the "first"
         byte[] ret = new byte[bArray.length - 1];
         for (int i = 0; i < ret.length; i++)
             ret[i] = bArray[i+1];
         return ret;
     }

     private static final int[] DIGITS_POWER
     // 0 1  2   3    4     5      6       7        8
     = {1,10,100,1000,10000,100000,1000000,10000000,100000000 };













M'Raihi, et al.               Informational                    [Page 10]

 
RFC 6238                      HOTPTimeBased                     May 2011


     /**
      * This method generates a TOTP value for the given
      * set of parameters.
      *
      * @param key: the shared secret, HEX encoded
      * @param time: a value that reflects a time
      * @param returnDigits: number of digits to return
      *
      * @return: a numeric String in base 10 that includes
      *              {@link truncationDigits} digits
      */

     public static String generateTOTP(String key,
             String time,
             String returnDigits){
         return generateTOTP(key, time, returnDigits, "HmacSHA1");
     }


     /**
      * This method generates a TOTP value for the given
      * set of parameters.
      *
      * @param key: the shared secret, HEX encoded
      * @param time: a value that reflects a time
      * @param returnDigits: number of digits to return
      *
      * @return: a numeric String in base 10 that includes
      *              {@link truncationDigits} digits
      */

     public static String generateTOTP256(String key,
             String time,
             String returnDigits){
         return generateTOTP(key, time, returnDigits, "HmacSHA256");
     }















M'Raihi, et al.               Informational                    [Page 11]

 
RFC 6238                      HOTPTimeBased                     May 2011


     /**
      * This method generates a TOTP value for the given
      * set of parameters.
      *
      * @param key: the shared secret, HEX encoded
      * @param time: a value that reflects a time
      * @param returnDigits: number of digits to return
      *
      * @return: a numeric String in base 10 that includes
      *              {@link truncationDigits} digits
      */

     public static String generateTOTP512(String key,
             String time,
             String returnDigits){
         return generateTOTP(key, time, returnDigits, "HmacSHA512");
     }


     /**
      * This method generates a TOTP value for the given
      * set of parameters.
      *
      * @param key: the shared secret, HEX encoded
      * @param time: a value that reflects a time
      * @param returnDigits: number of digits to return
      * @param crypto: the crypto function to use
      *
      * @return: a numeric String in base 10 that includes
      *              {@link truncationDigits} digits
      */

     public static String generateTOTP(String key,
             String time,
             String returnDigits,
             String crypto){
         int codeDigits = Integer.decode(returnDigits).intValue();
         String result = null;

         // Using the counter
         // First 8 bytes are for the movingFactor
         // Compliant with base RFC 4226 (HOTP)
         while (time.length() < 16 )
             time = "0" + time;

         // Get the HEX in a Byte[]
         byte[] msg = hexStr2Bytes(time);
         byte[] k = hexStr2Bytes(key);



M'Raihi, et al.               Informational                    [Page 12]

 
RFC 6238                      HOTPTimeBased                     May 2011


         byte[] hash = hmac_sha(crypto, k, msg);

         // put selected bytes into result int
         int offset = hash[hash.length - 1] & 0xf;

         int binary =
             ((hash[offset] & 0x7f) << 24) |
             ((hash[offset + 1] & 0xff) << 16) |
             ((hash[offset + 2] & 0xff) << 8) |
             (hash[offset + 3] & 0xff);

         int otp = binary % DIGITS_POWER[codeDigits];

         result = Integer.toString(otp);
         while (result.length() < codeDigits) {
             result = "0" + result;
         }
         return result;
     }

     public static void main(String[] args) {
         // Seed for HMAC-SHA1 - 20 bytes
         String seed = "3132333435363738393031323334353637383930";
         // Seed for HMAC-SHA256 - 32 bytes
         String seed32 = "3132333435363738393031323334353637383930" +
         "313233343536373839303132";
         // Seed for HMAC-SHA512 - 64 bytes
         String seed64 = "3132333435363738393031323334353637383930" +
         "3132333435363738393031323334353637383930" +
         "3132333435363738393031323334353637383930" +
         "31323334";
         long T0 = 0;
         long X = 30;
         long testTime[] = {59L, 1111111109L, 1111111111L,
                 1234567890L, 2000000000L, 20000000000L};

         String steps = "0";
         DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
         df.setTimeZone(TimeZone.getTimeZone("UTC"));












M'Raihi, et al.               Informational                    [Page 13]

 
RFC 6238                      HOTPTimeBased                     May 2011


         try {
             System.out.println(
                     "+---------------+-----------------------+" +
             "------------------+--------+--------+");
             System.out.println(
                     "|  Time(sec)    |   Time (UTC format)   " +
             "| Value of T(Hex)  |  TOTP  | Mode   |");
             System.out.println(
                     "+---------------+-----------------------+" +
             "------------------+--------+--------+");

             for (int i=0; i<testTime.length; i++) {
                 long T = (testTime[i] - T0)/X;
                 steps = Long.toHexString(T).toUpperCase();
                 while (steps.length() < 16) steps = "0" + steps;
                 String fmtTime = String.format("%1$-11s", testTime[i]);
                 String utcTime = df.format(new Date(testTime[i]*1000));
                 System.out.print("|  " + fmtTime + "  |  " + utcTime +
                         "  | " + steps + " |");
                 System.out.println(generateTOTP(seed, steps, "8",
                 "HmacSHA1") + "| SHA1   |");
                 System.out.print("|  " + fmtTime + "  |  " + utcTime +
                         "  | " + steps + " |");
                 System.out.println(generateTOTP(seed32, steps, "8",
                 "HmacSHA256") + "| SHA256 |");
                 System.out.print("|  " + fmtTime + "  |  " + utcTime +
                         "  | " + steps + " |");
                 System.out.println(generateTOTP(seed64, steps, "8",
                 "HmacSHA512") + "| SHA512 |");

                 System.out.println(
                         "+---------------+-----------------------+" +
                 "------------------+--------+--------+");
             }
         }catch (final Exception e){
             System.out.println("Error : " + e);
         }
     }
 }

 <CODE ENDS>

Appendix B.  Test Vectors

   This section provides test values that can be used for the HOTP time-
   based variant algorithm interoperability test.





M'Raihi, et al.               Informational                    [Page 14]

 
RFC 6238                      HOTPTimeBased                     May 2011


   The test token shared secret uses the ASCII string value
   "12345678901234567890".  With Time Step X = 30, and the Unix epoch as
   the initial value to count time steps, where T0 = 0, the TOTP
   algorithm will display the following values for specified modes and
   timestamps.

  +-------------+--------------+------------------+----------+--------+
  |  Time (sec) |   UTC Time   | Value of T (hex) |   TOTP   |  Mode  |
  +-------------+--------------+------------------+----------+--------+
  |      59     |  1970-01-01  | 0000000000000001 | 94287082 |  SHA1  |
  |             |   00:00:59   |                  |          |        |
  |      59     |  1970-01-01  | 0000000000000001 | 46119246 | SHA256 |
  |             |   00:00:59   |                  |          |        |
  |      59     |  1970-01-01  | 0000000000000001 | 90693936 | SHA512 |
  |             |   00:00:59   |                  |          |        |
  |  1111111109 |  2005-03-18  | 00000000023523EC | 07081804 |  SHA1  |
  |             |   01:58:29   |                  |          |        |
  |  1111111109 |  2005-03-18  | 00000000023523EC | 68084774 | SHA256 |
  |             |   01:58:29   |                  |          |        |
  |  1111111109 |  2005-03-18  | 00000000023523EC | 25091201 | SHA512 |
  |             |   01:58:29   |                  |          |        |
  |  1111111111 |  2005-03-18  | 00000000023523ED | 14050471 |  SHA1  |
  |             |   01:58:31   |                  |          |        |
  |  1111111111 |  2005-03-18  | 00000000023523ED | 67062674 | SHA256 |
  |             |   01:58:31   |                  |          |        |
  |  1111111111 |  2005-03-18  | 00000000023523ED | 99943326 | SHA512 |
  |             |   01:58:31   |                  |          |        |
  |  1234567890 |  2009-02-13  | 000000000273EF07 | 89005924 |  SHA1  |
  |             |   23:31:30   |                  |          |        |
  |  1234567890 |  2009-02-13  | 000000000273EF07 | 91819424 | SHA256 |
  |             |   23:31:30   |                  |          |        |
  |  1234567890 |  2009-02-13  | 000000000273EF07 | 93441116 | SHA512 |
  |             |   23:31:30   |                  |          |        |
  |  2000000000 |  2033-05-18  | 0000000003F940AA | 69279037 |  SHA1  |
  |             |   03:33:20   |                  |          |        |
  |  2000000000 |  2033-05-18  | 0000000003F940AA | 90698825 | SHA256 |
  |             |   03:33:20   |                  |          |        |
  |  2000000000 |  2033-05-18  | 0000000003F940AA | 38618901 | SHA512 |
  |             |   03:33:20   |                  |          |        |
  | 20000000000 |  2603-10-11  | 0000000027BC86AA | 65353130 |  SHA1  |
  |             |   11:33:20   |                  |          |        |
  | 20000000000 |  2603-10-11  | 0000000027BC86AA | 77737706 | SHA256 |
  |             |   11:33:20   |                  |          |        |
  | 20000000000 |  2603-10-11  | 0000000027BC86AA | 47863826 | SHA512 |
  |             |   11:33:20   |                  |          |        |
  +-------------+--------------+------------------+----------+--------+

                            Table 1: TOTP Table



M'Raihi, et al.               Informational                    [Page 15]

 
RFC 6238                      HOTPTimeBased                     May 2011


Authors' Addresses

   David M'Raihi
   Verisign, Inc.
   685 E. Middlefield Road
   Mountain View, CA  94043
   USA

   EMail: davidietf@gmail.com


   Salah Machani
   Diversinet Corp.
   2225 Sheppard Avenue East, Suite 1801
   Toronto, Ontario  M2J 5C2
   Canada

   EMail: smachani@diversinet.com


   Mingliang Pei
   Symantec
   510 E. Middlefield Road
   Mountain View, CA  94043
   USA

   EMail: Mingliang_Pei@symantec.com


   Johan Rydell
   Portwise, Inc.
   275 Hawthorne Ave., Suite 119
   Palo Alto, CA  94301
   USA

   EMail: johanietf@gmail.com

# vsftpd 주요 서비스

# vsftpd 관련 파일

# 계정별 vsftpd 접속제한 파일

# /etc/vsftpd/vsftpd.conf 설정옵션

출처 : http://oracle.tistory.com/129 (안나푸르나)

SFTP는 기본적으로 로그를 남지 않습니다, 때문에 파일의 변경/삭제가 어떻게 된 것인 찾기가 곤란할 수 있습니다.

이번에 소개해 드릴 openssh 및 syslog의 간단한 설정으로 SFTP 작업 로그 남기는 방법에 대해 소개 드립니다.

1. /etc/ssh/sshd_config 의 편집

아래의 라인을 수정이나 추가해 줍니다.
보통 ‘Subsystem’이 주석 처리되어 있을 것이니 주석을 해제하고 아래와 같이 수정/추가해 주시면 됩니다.

추가할 내용 : Subsystem       sftp    /usr/libexec/openssh/sftp-server -f local2 -l INFO

명령: # echo “Subsystem       sftp    /usr/libexec/openssh/sftp-server -f local2 -l INFO” >> /etc/ssh/sshd_config
          # tail /etc/ssh/sshd_config

sftp-server에 대한 자세한 설정 사항은 “man sftp-server” 로 옵션 사항을 참고하세요.

2. syslog.conf 나 rsyslog.con 파일 수정

저는 경우 rsyslog를 사용하여 /etc/rsyslog.conf 에 내용을 추가 했습니다.

추가 내용  : local2.*                                        /var/log/sftp.log

명령: # echo “local2.*                                        /var/log/sftp.log” >> /etc/rsyslog.conf
         # tail /etc/rsyslog.conf

3. 로그 파일 생성 : sftp.log

sftp.log 파일은 syslog나 rsyslog 서비스를 재시작 해주면 자동으로 생성이 된다, 만약 생성이 되지 않았을 경우 다음 명령으로 생성해 줍니다.

명령:  # touch /var/log/sftp.log

4. rsyslog, sshd,서비스 재시작

명령 : # /etc/init.d/rsyslog restart 또는 /etc/init.d/syslog restart
          # /etc/init.d/sshd restart

5. 로그 남김 확인
sftp 테스트 접속 후 로그를 보자

명령 : # tail -f /var/log/sftp.log

6. 로그로테이트 추가
로그가 기록되는 것이 확인되었다면, 마지막으로 로그로테이트에 sftp.log를 추가하여, 일정 용량 이상일 경우 로그를 백업하도록 하자.
/etc/logrotate.d/syslog 에 “/var/log/sftp.log” 를 추가하자.