구글크롬 테스트 및 브라우저버전체크 스크립트

Javascript 궁금하니? 2009. 11. 10. 15:21

출처: http://techbug.tistory.com/123

브라우저 춘추전국시대 다시 시작하나....

오늘 구글크롬이 다운로드 서비스를 시작했다.
설치후 구글 크롬 이놈은 다른 브라우저의 종합판인듯하다.

Opera,Firefox, Safari 모두다 섞어 놓은것 같은데.. ㅡ.,ㅡ;  상상력이... 쿨럭!!.



각 브라우저의 값들을 비교해보고자
alert(navigator.userAgent+"\n=>"+parseFloat(navigator.appVersion));로 찍어봤다.

구글크롬 0.2
Mozilla/5.0 (Windows; U; Windows NT 6.0; en-US) AppleWebKit/525.13 (KHTML, like Gecko) Chrome/0.2.149.27 Safari/525.13:
=>Netscape

사파리  3.1.2
Mozilla/5.0 (Windows; U; Windows NT 6.0; ko-KR) AppleWebKit/525.19 (KHTML, like Gecko) Version/3.1.2 Safari/525.21:
=>Netscape

Firefox 3
Mozilla/5.0 (Windows; U; Windows NT 6.0; ko; rv:1.9.0.1) Gecko/2008070208 Firefox/3.0.1:
=>5

IE7
Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 6.0; Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1) ; SLCC1; .NET CLR 2.0.50727; Media Center PC 5.0; .NET CLR 3.0.04506):
=>4

Opera 9.52
Opera/9.52 (Windows NT 6.0; U; ko):
=>Opera

헉.. 이놈 대단한 놈이다.. safari의 AppleWebkit으로도 유효성검증을 하기가.. ㅠ.,ㅠ;
결국은 다음과 같이 버전체크 부분을 몽땅 바꿔버렸다.

/**
 * @fileoverview 브라우저비교 및 JS상속, 클래스 생성관련 스크립트 모음
 * @author 데꾸벅
 * @version 0.1
 * @since 2003.05.08, 2008.08.27 IE6 판별 버그 수정, 2008.09.03 Google Chrome 판별 추가
 */


 var sUserAgent = navigator.userAgent;
var fAppVersion = parseFloat(navigator.appVersion);

/**
 * 브라우저 버전 비교
 */
function compareVersions(sVersion1, sVersion2) {
    var aVersion1 = sVersion1.split(".");
    var aVersion2 = sVersion2.split(".");

    if (aVersion1.length > aVersion2.length) {
        for (var i=0; i < aVersion1.length - aVersion2.length; i++) {
            aVersion2.push("0");
        }
    } else if (aVersion1.length < aVersion2.length) {
        for (var i=0; i < aVersion2.length - aVersion1.length; i++) {
            aVersion1.push("0");
        }
    }
    for (var i=0; i < aVersion1.length; i++) {
        if (aVersion1[i] < aVersion2[i]) {
            return -1;
        } else if (aVersion1[i] > aVersion2[i]) {
            return 1;
        }
    }
    return 0;
}



//Opera
var isOpera = sUserAgent.indexOf("Opera") > -1;
var isOpera7 = isOpera8 = isOpera9 =isOpera10 = false;
if (isOpera) {
    if (/Opera[\/\s](\d+\.\d+)/.test(navigator.userAgent)){
     var oprversion=new Number(RegExp.$1);
     if (oprversion>=10) isOpera10 = true;
     else if (oprversion>=9) isOpera9 = true;
     else if (oprversion>=8) isOpera8 = true;
     else if (oprversion>=7) isOpera7 = true;
    }
}




//KHTML, Konqueror
var isKHTML = sUserAgent.indexOf("KHTML") > -1 || sUserAgent.indexOf("Konqueror") > -1  || sUserAgent.indexOf("AppleWebKit") > -1;

var isSafari1 = isSafari1_2 = false;
var isKonq2_2 = isKonq3 = isKonq3_1 = isKonq3_2 = false;
var isSafari = false;
if (isKHTML) {
    isSafari = sUserAgent.indexOf("AppleWebKit") > -1;
    isKonq = sUserAgent.indexOf("Konqueror") > -1;

    if (isSafari) {
        var reAppleWebKit = new RegExp("AppleWebKit\\/(\\d+(?:\\.\\d*)?)");
        reAppleWebKit.test(sUserAgent);
        var fAppleWebKitVersion = parseFloat(RegExp["$1"]);
        isSafari1 = fAppleWebKitVersion >= 85;
        isSafari1_2 = fAppleWebKitVersion >= 124;
    } else if (isKonq) {
        var reKonq = new RegExp("Konqueror\\/(\\d+(?:\\.\\d+(?:\\.\\d)?)?)");
        reKonq.test(sUserAgent);
        isKonq2_2 = compareVersions(RegExp["$1"], "2.2") >= 0;
        isKonq3 = compareVersions(RegExp["$1"], "3.0") >= 0;
        isKonq3_1 = compareVersions(RegExp["$1"], "3.1") >= 0;
        isKonq3_2 = compareVersions(RegExp["$1"], "3.2") >= 0;
    }
}


// Internet Explorer
var isIE = sUserAgent.indexOf("compatible") > -1 && sUserAgent.indexOf("MSIE") > -1 && !isOpera;
var isIE4 = isIE5 = isIE5_5 = isIE6 = isIE7 = isIE8 = false;
if (isIE) {
    var reIE = new RegExp("MSIE (\\d+\\.\\d+);");
    reIE.test(sUserAgent);
    var fIEVersion = parseFloat(RegExp["$1"]);
    isIE4 = fIEVersion >= 4  && fIEVersion < 5;
    isIE5 = fIEVersion >= 5  && fIEVersion < 5.5;
    isIE5_5 = fIEVersion >= 5.5  && fIEVersion < 6.0;
    isIE6 = fIEVersion >= 6.0 && fIEVersion < 7.0;
    isIE7 = fIEVersion >= 7.0 && fIEVersion < 8.0;
    isIE8 = fIEVersion >= 8.0 ;
}


// Mozilla 여부
var isMoz = sUserAgent.indexOf("Gecko") > -1 && !isKHTML;
var isMoz1 = sMoz1_4 = isMoz1_5 = false;

if (isMoz) {
    var reMoz = new RegExp("rv:(\\d+\\.\\d+(?:\\.\\d+)?)");
    reMoz.test(sUserAgent);
    isMoz1 = compareVersions(RegExp["$1"], "1.0") >= 0;
    isMoz1_4 = compareVersions(RegExp["$1"], "1.4") >= 0;
    isMoz1_5 = compareVersions(RegExp["$1"], "1.5") >= 0;
}

var isNS4 = !isIE && !isOpera && !isMoz && !isKHTML && (sUserAgent.indexOf("Mozilla") == 0) && (navigator.appName == "Netscape") && (fAppVersion >= 4.0 && fAppVersion < 5.0);
var isNS4 = isNS4_5 = isNS4_7 = isNS4_8 = false;

if (isNS4) {
    isNS4 = true;
    isNS4_5 = fAppVersion >= 4.5;
    isNS4_7 = fAppVersion >= 4.7;
    isNS4_8 = fAppVersion >= 4.8;
}


var isFF = !isIE && !isOpera && isMoz && !isKHTML && (sUserAgent.indexOf("Mozilla") == 0) && (navigator.appName == "Netscape");
var isFF1 = isFF2 = isFF3 = false;
if(isFF){
    if (/Firefox[\/\s](\d+\.\d+)/.test(navigator.userAgent)){
     var ffversion=new Number(RegExp.$1);
     if (ffversion>=3)
          isFF3 = true;
     else if (ffversion>=2)
         isFF2 = true;
     else if (ffversion>=1)
          isFF1 = true;
    }
}


//구글 크롬 버전체크 추가 2008.09.03
var isChrome = !isIE && !isFF && !isOpera && !isMoz && !isKonq && isSafari && isKHTML && (sUserAgent.indexOf("Mozilla") == 0) && (sUserAgent.indexOf("Chrome") != -1) && (navigator.appName == "Netscape");
var isChrome02 = false;

if(isChrome){
    if (/Chrome[\/\s](\d+\.\d+)/.test(navigator.userAgent)){
        var ffversion=new Number(RegExp.$1);
        if(parseFloat(ffversion) >= parseFloat('0.2'))
            isChrome02 = true;
    }
}


/**
 * XP인지 아닌지 판별함수
 * @return {boolean} true/false
 */
function isXP(){
    var agent = window.navigator.userAgent;
    if(agent.indexOf("MSIE")!= -1 && agent.indexOf("5.1") !=-1)
        return true;     //SP1
    else
        return false;
}

/**
 * XP의 ServicePack2인지 처리함수
 * @return {boolean} true/false
 */
function isXPSP2(){
    var tmp_MSIE = window.navigator.userAgent.indexOf("MSIE");
    if(tmp_MSIE && window.navigator.userAgent.indexOf("SV1") > tmp_MSIE){
        return true;     //SP2
    }else{
        return false;
    }
}


 

사용자 삽입 이미지



구글크롬에서는 태터툴즈의 웹에디팅기능이 되지 않아 지금 포스팅은 FF3에서 작성하고 있다. ㅡ.,ㅡa


Acid3 Test 결과화면 : 테스트사이트 (http://acid3.acidtests.org/)

사용자 삽입 이미지

Opera9, Firefox3, IE7,
Safari, google Chrome, IE8
순서로 테스트 (Safari는 네트웍때문에 연결되지 않았으며, google Chrome의 경우 78/100 이 나왔습니다. 사파리하고 비슷한 수준이네요~~



근데... 이건 뭥미???

사용자 삽입 이미지
AND

정규식(Regular Expression) 표현 방법 및 예제

Javascript 궁금하니? 2009. 11. 10. 15:19

출처: http://kurapa.com/content-a6250

1) 객체

그럼 먼저 정규식의 객체에 대해 살펴보자. 정규식의 모든 객체를 설명하려면 너무 복잡하고 어려우므로 여기에선 일단 가장 중요한 것들만 나열한다.

(1) 문자

    * 유니코드 문자 - 유니코드 문자는 문자 그대로 표현한다. 즉, a는 문자열의 a와 매치된다.
    * \ (backslash) - 정규식에 사용되는 특수문자, 예를 들어 * 나 \ 등을 매치할때 사용한다. 즉, * 를 매치하려면 \* 라고 써줘야한다.
    * \t - 탭 문자와 매치된다.
    * \n - 새줄문자와 매치된다.
    * \r - 리턴문자와 매치된다.
    * \f - form feed문자와 매치된다.

예를 들어 문자열 "a\bc*"와 매칭을 하고 싶다면 정규식은 "a\\bc\*"와 같이 사용한다. \와 *가 모두 정규식에 쓰이는 특수문자들이므로 앞에 \을 붙여주고 나머지는 문자 그대로 사용한다.

(2) 문자클래스

    * [a-zA-Z] - a에서 z까지, 그리고 A에서 Z사이에 있는 모든 문자와 매치된다.
    * [^a-zA-Z] - 위와 반대다. 즉 a에서 z까지, A에서 Z까지 사이에 없으면 매치된다.

만약 소문자와 매치하려면 [a-z]를 사용하거나 [^A-Z]를 사용하면 된다. 숫자도 마찬가지다. [0-9]를 사용하면 숫자와 매치되고 숫자가 아닌 것과 매치하려면 [^0-9]를 사용하면 된다.

(3) 사전에 정의된 클래스

    * . - 새줄문자 이외의 모든것
    * \w - 알파벳과 _ (영어단어에 쓰이는 문자)
    * \W - 알파벳과 _이 아닌 것
    * \s - 빈 공간
    * \S - 빈 공간이 아닌 것
    * \d - 숫자
    * \D - 숫자가 아닌 것

예를 들어 "1a 2a" 또는 "3g 9i" 등의 문자열과 매치하고 싶을 땐 "\d\S\s\d\S"와 같이 정규식을 써주면 된다.

(4) 단어나 줄의 경계를 매치할때

    * ^ - 줄의 맨앞과 매치된다.
    * $ - 줄의 맨끝과 매치된다.
    * \b - 단어와 단어의 경계와 매치된다.

예를 들어 한 줄에 "aaaaa"라는 문자열만 있는 줄을 매치하고 싶으면 "^aaaaa$"와 같이 정규식을 써주면 된다. 만약 다른 문자열 속에 포함돼있는 "aaaaa"를 매치하고 싶다면 (예를 들어 "bbbbbaaaaabbbbb") 그냥 "aaaaa"만 해줘야 매치가 된다.

(5) 그 이외의 것들

    * A|B - A 또는 B와 매치된다.
    * (A) - A와 매치한것을 나중에 다시 사용할 때 쓴다.

어떤 문자열에서 매치한 부분을 나중에 다시 사용하고 싶을 때는 괄호를 사용한다. 예를 들어 사용자가 입력한 전화번호를 정규식을 사용하여 패턴매칭을 했다고 하자. 이렇게 매치된 전화번호를 데이터베이스에 저장하고 싶을 때 바로 정규식 안에서 괄호를 이용하여 매칭을 한다. 괄호 안에 매칭된 부분은 나중에 다시 사용하는 것이 가능하기 때문이다. 이것은 굉장히 중요하므로 나중에 예제로 다시 설명하겠다.

(6) 매치된 객체의 재사용

    *  \1 - 첫번째 괄호에 매치된 부분
    *  \2 - 두번째 괄호에 매치된 부분
    *  세번째는 $3, 네번째는 $4 등으로 사용하면 됨

정규식 안에서 괄호에 매치된 부분을 다시 사용하고 싶을 때 쓰는 객체들이다. 예를 들어 "1 - 1" 처럼 처음과 나중의 숫자가 같은 문자열만 매칭하고 싶을 경우, "(\d+) \- \1"과 같은 정규식을 사용하면 간단하게 매칭할 수 있다. 여기서 \1 은 그 앞에서 \d+ 로 매치된 숫자를 가리킨다.

(7) 수량

수량은 각 객체가 문자열 안에서 몇 번이나 나타나는지 그 회수를 정해준다. 아마 많은 독자들이 윗부분을 보면서 정규식은 문자를 한 번에 한 개밖에 매치하지 못하나 하고 의문을 품을지 모르겠다. 그러나, 바로 밑에 나열한 것들로 수량을 정해줄 수 있다. 일단 그것들을 보고 예제를 통해서 사용 방법을 살펴보자.

    * A* - A를 0번, 아니면 그 이상 매치한다.
    * A+ - A를 한번, 아니면 그 이상 매치한다.
    * A? - A를 0번, 아니면 한번만 매치한다.
    * A{n} - A를 정확히 n번 매치한다.
    * A{n,} - A를 n번 이상 매치한다.
    * A{n,m} - A를 최소한 n번, 하지만 m번 이하로 매치한다.


2) 정규식 예제

지금까지 나열한 모든 객체들을 예제를 통해서 자세히 알아보도록 하자. 만약 전화번호를 매치하고 싶다면 어떻게 해야할까? 일단 전화번호는 지역번호가 있을수도, 없을수도 있다. 사람마다 지역번호를 괄호에 넣거나, 아니면 그냥 국번과 -로 구별하기도 한다. 그럼 그것에 맞는 정규식은 어떻게 써야할까? 일단 지역번호를 매치해보자. 지역번호는 세자리 숫자이므로

\d{3}

으로 하면 매치가 된다. 물론 너무 엄격하게 하고 싶지 않으면

\d+

로 해도 된다. 그렇다면 괄호의 있고 없고 여부는 어떻게 해야할까? 여기에선 ?나 *를 쓰면 해결할 수 있다. 즉,

\(?\d{3}\)?

을 쓰면 지역번호와 패턴매칭을 할 수 있다. 전화번호의 나머지도 간단하다.

\d{3,4}\-?\d{4}

로 하면 간단히 매치된다. 국번은 세자리, 또는 네자리지만 번호는 네자리밖에 없다. 요약하면 전화번호를 매치하기 위해선

\(?\d{3}\)?\-?\d{3,4}\-?\d{4}

와 같은 정규식이 필요하다. 그럼 위의 정규식을 써서 전화번호를 찾아냈다고 하자. 하지만 그 전화번호가 무엇인지 어떻게 알 수 있을까? 문자열을 그대로 다시 출력하면 매칭한 부분뿐만 아니라 다른 부분들까지 출력하게 된다. 여기서 매치된 부분만 다시 사용하기 위해 괄호를 사용하면 된다. 예를 들어, 위의 전화번호를 지역번호와 국번, 그리고 번호의 세 부분으로 나눠서 재사용 해보기로 하자. 그렇다면 다음처럼 각 부분에 괄호를 사용하면 된다.

\(?(\d{3})\)?\-?(\d{3,4})\-?(\d{4})

처음보단 훨씬 복잡하게 보이지만 객체 하나하나를 풀어서 보면 쉽게 알 수 있다. 만약 전화번호가 123-456-7890 이였다면 첫번째 괄호는 123, 두번째 괄호는 456, 그리고 마지막 괄호는 7890과 매치하게 된다. 이제 매치된 부분을 재사용하려면 Regexp 패키지의 getParen()이라는 함수를 사용하면 된다. 즉, getParen(1)은 123을, getParen(2)는 456을, 그리고 getParen(3)은 7890을 돌려준다. 이것은 클래스 사용방법에 더 자세히 설명돼 있으므로 패키지 사용방법 문서를 읽어주기 바란다.

그럼 여기서 연습을 한 번 해보자. 만약 주민등록번호를 매치하고 싶다면 어떤 정규식을 써야할까? 이건 독자 여러분이 각자 해보기 바란다. 정답은 이 문서 맨 밑에 있다.

여기서 한 가지 짚고 넘어가야 할 것은 정규식엔 한 가지의 정답이란 없다는 것이다. 개발자가 원하는 결과가 제대로 나오도록만 정의해주면 된다는 것이다. 예를 들어 앞의 전화번호의 예제를 보자. 국번의 경우 \d{3} 도 가능했고 \d+ 도 가능했다. 개발자가 원하는 것을 사용하면 된다.

출처: http://kurapa.com

AND

해쉬 알고리즘

Algorithm 궁금하니? 2009. 10. 22. 21:18

출처: http://blog.naver.com/eunyeop?Redirect=Log&logNo=130008937107

 

해쉬 알고리즘

해쉬함수($ H$혹은 Hash로 표기)는 임의의 길이의 입력 메세지를 고정된 길이의 출력값으로 압축시키는 함수이다. 데이타의 무결성 검증, 메세지 인증에 사용한다. 해쉬함수는 다음의 성질을 만족해야 한다.

  • 일방향성 : 주어진 해쉬값 $ h$에 대해서 $ H(x)=h$를 만족하는 $ x$를 찾는것이 계산적으로 불가능
  • 강한 충돌 회피성 : 주어진 $ x$에 대해 $ H(x)=H(y)$를 만족하는 임의의 입력 메세지 $ y( ne x)$를 찾는 것이 계산적으로 불가능

일반적으로 널리 쓰이는 해쉬함수로는 MD5, SHA1, RMD160, TIGER 등이 있다.


표 4: 해쉬 알고리즘
알고리즘 출력길이 블럭의 크기 라운드 수 Endianness
MD5 128 512 64 Little
SHA1 160 512 80 Big
SHA256 256 512 64 Big
SHA384 384 1024 80 Big
SHA512 512 1024 80 Big
RMD128 128 512 128 Little
RMD160 160 512 160 Little
RMD256 256 512 128 Little
RMD320 320 512 160 Little
HAS160 160 512 80 Little
TIGER 192 512 56 Little

  • MD5는 널리 사용된 해쉬 알고리즘이지만, 충돌 회피성에서 문제점이 있다는 분석이 있으므로 기존의 응용과의 호환으로만 사용하고 더 이상 사용하지 않도록 하고 있다.
  • SHA1은 DSA에서 사용하도록 되어 있으며 많은 인터넷 응용에서 default 해쉬 알고리즘으로 사용된다.
  • SHA256, SHA384, SHA512는 AES의 키 길이인 128, 192, 256 비트에 대응하도록 출력길이를 늘인 해쉬알고리즘이다.
  • RMD128, RMD160는 RIPE 프로젝트의 RIPEMD나 MD4, MD5를 대신하기 위하여 디자인된 해쉬 알고리즘이다. 128 비트의 출력을 내는 RMD128은 역시 충돌 회피성에서 문제점이 있다. RMD160은 효율성은 떨어지지만 안전성을 높인 것으로 많은 인터넷 표준들에서 널리 채택되고 있다.
  • RMD256과 RMD320은 각각 RMD128과 RMD160을 확장한 것이다.
  • HAS160은 국내 표준 서명 알고리즘 KCDSA를 위하여 개발된 해쉬 함수이다. MD5와 SHA1의 장점을 취하여 디자인 되었다. 현재 TTA 표준으로 제정중에 있다.
  • TIGER는 64 비트 프로세서에 최적화되어서 64 비트 프로세서에서는 매우 빠르다.

MAC 알고리즘

MAC(Message Authentication Code)은 파일내용의 변경 유무나 통신상에서 오가는 데이타의 무결성을 체크하는데 이용된다.

  • 해쉬함수 기반 : HMAC, KMAC
  • 블럭 암호 기반 : CBC-MAC(ISO 9797-1), RIPE-MAC, XCBC
  • 모듈라 곱셈 기반 : UMAC

HMAC

HMAC (RFC 2104)은 해쉬함수를 사용하여 MAC을 생성하는 방법이다

$ H(  (K oplus {rm opad}) vertvert  H( (K oplus {rm ipad}) vertvert  text ) ).$
  • $ H$ : 해쉬함수. MD5, SHA1, RMD160, HAS160, TIGER 등을 이용.
  • $ K$ : 비밀키. 키의 길이에는 제한이 없다.
  • opad : 0x5C를 블럭의 크기(바이트)만큼 연접한것.
  • ipad : 0x36를 블럭의 크기(바이트)만큼 연접한것.
  • 출력의 일부만을 MAC으로 사용하는 truncation을 사용하기도 한다.

KMAC

해쉬함수를 이용한 MAC으로 HMAC이 나온 이후 잘 사용되지 않는다. 예를들어 MD5에 대한 KMAC은 다음과 같다.

$displaystyle K'$ $displaystyle = K vertvert$   (MD5 padding)$displaystyle ,$    
$displaystyle Data'$ $displaystyle = K' vertvert Data vertvert K ,$    
$displaystyle {rm MAC}$ $displaystyle = {rm MD5}(Data')$    



CBC-MAC

CBC-MAC은 $ n$-비트 블럭 암호의 CBC 모드를 이용한 MAC이다.

  • ISO 9797-1의 CBC-MAC-MAC1, MAC2, MAC3, MAC4, MAC5, MAC6.
  • RIPE-MAC (RIPE 프로젝트)
  • XCBC (Crypto 2000)

ISO/IEC 9797-1의 CBC-MAC

ISO 9797-1의 CBC-MAC 알고리즘의 순서는 다음과 같다.

  1. Padding
  2. Splitting
  3. Initial transformation
  4. Iteration
  5. Output transformation
  6. Truncation
  • Padding:
    • PAD1 - zero padding
    • PAD2 - one-zero padding
    • PAD3 - PAD1을 한 뒤, 최상위 블럭에 데이터 길이를 추가
  • splitting:
    • 패딩된 데이타를 블럭의 크기로 나누어서 $ D_1, cdots, D_{q}$의 데이타 블럭을 만든다.
  • Initial transformation:
    • IniTrans1 - $ H_{1}=e_{K}(D_{1})$
    • IniTrans2 - $ H_{1}=e_{K''}(e_{K}(D_{1}))$
  • iteration: $ i=2, cdots,q$ 에 대해서 $ D_{i}$에 CBC 모드의 블럭 암호를 적용한다.
    $ H_{i}=e_{K}(D_{i}oplus H_{i-1}) quad$ for $ i=2, cdots,q$.
  • Output transformation:
    • OutTrans1 - $ G=H_{q}$
    • OutTrans2 - $ G=e_{K'}(H_{q})$
    • OutTrans3 - $ G=e_{K}(d_{K^{prime}}(H_{q}))$
  • truncation: $ G$의 상위 $ m$ 비트를 truncate하여 MAC값으로 한다.

여기서 initial transformation과 output transformation을 조합하는 방법에 따라서 여러가지의 MAC 알고리즘으로 나뉜다.

  • MAC 1 : IniTrans1 + OutTrans1.
    그림 6: MAC 1

    MAC 1이 안전성측면에서 가장 취약하지만 현재 대부분의 표준에서는 zero padding(Pad1)을 한 뒤의 MAC 1을 사용하고, 다른 모드는 실제로 쓰이는 표준이 별로 없다.

  • MAC 2 : IniTrans1 + OutTrans2
    그림 7: MAC 2
  • MAC 3 : IniTrans1 + OutTrans3
    그림 8: MAC 3
  • MAC 4 : IniTrans2 + OutTrans2
    그림 9: MAC 4
  • MAC 5

    MAC 5는 MAC 1을 parallel하게 두번 사용하여 얻는다. 주어지는 key는 $ K$ 하나이며 $ K$로 부터 각각의 MAC 1 알고리즘에서 사용할 두 개의 키 $ K_{1}$과 $ K_{2}$를 유도해서 사용하는데, $ K_{1}$과 $ K_{2}$는 서로 달라야 한다. 구체적인 MAC값은 $ K_{1}$을 사용한 $ {rm MAC_{1}}$의 값과 $ K_{2}$을 사용한 $ {rm MAC_{2}}$의 값을 XOR하여 구한다.

    $ {rm MAC:=MAC_{1} oplus MAC_{2}}$.
  • MAC 6

    MAC 6은 MAC 4를 parallel하게 두번 사용하여 얻는다. 주어지는 키는 ($ K$, $ K'$)이고 이로부터 각각의 MAC 4 알고리즘에서 사용한 두쌍의 키 $ (K_{1},K_{1}')$과 $ (K_{2},K_{2}')$을 유도한다.

    $ (K_{1},K_{1}')$를 사용한 MAC 4 알고리즘으로 $ {rm MAC_{1}}$을 구하고, $ (K_{2},K_{2}')$를 사용한 MAC 4 알고리즘으로 $ {rm MAC_{2}}$을 구하여 XOR하여 MAC을 구한다.

    $ {rm MAC:=MAC_{1} oplus MAC_{2}}$.

RIPE-MAC

RIPE-MAC은 RIPE 프로젝트의 하나로 디자인된 CBC-MAC이다.

  • ISO 9797-1을 바탕으로 디자인
  • DES와 2-key 3DES를 사용
  • 패딩방법 : PAD2를 한 뒤, 최하위 블럭에 데이타 길이를 추가
  • 변형된 CBC 모드를 사용
  • 키 유도 방법을 명확히 하였다.
  • truncation을 하지 않음.

패딩된 데이터를 블럭의 크기대로 $ D_1, D_2, cdots, D_q$로 나누고 다음과 같은 변형된 CBC 모드를 사용하여 $ H_q$를 구한다.

그림 10: RIPE-MAC

$ H_q$를 구하면 $ K'$을 다음과 같이 구한다.

begin{displaymath} K' = begin{cases} K oplus {tt0x F0F0F0F0 F0F0F0F0}, & mb... ...(K_1' vertvert K_2'), & mbox{ if } e={rm 3DES}. end{cases}end{displaymath}

단 여기서 $ K_i' = K_i oplus {tt0x F0F0F0F0 F0F0F0F0}$ 이다. 그러면 MAC은 다음과 같다.

$displaystyle {rm MAC} = e_{K'}(H_q).$

XCBC-MAC

  • 불필요한 패딩을 없앰.
  • 암호화 키를 1개만 사용하여 key scheduling 시간을 줄임.

데이터에 패딩할때, 데이터 블럭의 수가 증가하지 않도록 데이터의 길이가 $ n$ 비트의 배수일 때와 아닐 때로 나누어서 $ n$ 비트의 배수가 아닌 경우에만 최소길이의 ` $ {tt 10cdots 0}$'를 덧붙여서 데이터의 길이를 $ n$ 비트의 배수로 만든다.

XCBC-MAC은 세개의 키 $ (K_1, K_2, K_3)$가 필요한데, $ K_1$은 암호화할 때 필요한 암호화 키이고 $ K_2, K_3$는 데이터의 마지막 블럭에만 적용되는 Input whitening 키로서 데이터의 패딩방법에 따라서 $ K_2$ 혹은 $ K_3$가 선택된다.

그림 11: XCBC-MAC

패딩된 데이터를 블럭의 크기로 나누어 $ D_1, D_2, cdots, D_q$로 만들면 $ H_{q-1}$까지는 $ IV=0$인 보통의 CBC 모드로 구해진다. 마지막 $ H_q (={rm MAC})$은 패딩이 일어난 경우와 일어나지 않은 경우로 나누어 다음과 같이 구한다.

begin{displaymath} H_q = begin{cases} e_{K_1}(H_{q-1} oplus D_q oplus K_2), ... ...& mbox{데이터의 길이가 $n$ 비트의 배수가 아닐 때}. end{cases}end{displaymath}

UMAC

  • J. Black et el.에 의해서 설계(Crypto'99)
  • 16 비트/32 비트 곱셈을 사용한 universal hash 함수를 이용
  • 곱셈이 빠르게 구현되는 프로세서 환경에서는 기존의 HMAC이나 CBC-MAC보다 매우 빠르게 구현될 수 있다.
  • 워드의 길이만큼 차례로 연접하여 구해짐. UMAC의 출력의 길이가 길어질수록 길이에 비례하여 안전해지고 UMAC을 구하는데 걸리는 시간도 길이에 비례하여 증가하게 된다.


표 5: UMAC의 파라미터
  파라미터 가능한 값 Default 설명
$ w$ WORD-LEN 2, 4 4 word의 길이(바이트)
$ l$ UMAC-OUTPUT-LEN 1, 2, $ cdots$, 31, 32 8 UMAC의 출력 길이(바이트)
$ n$ L1-KEY-LEN 32, 64, 128, $ cdots$, $ 2^{28}$ 1024 Layer1의 NH에서 처리되는 메세지 단위(바이트)
$ k$ UMAC-KEY-LEN 16, 32 16 사용자 키 길이(바이트)
$ s$ L1-OPERATION-SIGN SIGNED, UNSIGNED UNSIGNED  
$ e$ ENDIAN-FAVORITE BIG, LITTLE LITTLE  


각 파라미터는 주어진 word의 길이($ w$)에 대하여 임의로 정해질 수 있으며 그 때의 UMAC의 버젼은 UMAC- $ w/l/n/k/s/e$로 나타내고 특히 default UMAC은 UMAC32라고 한다. 그리고 UMAC16은 UMAC-2/8/1024/16/SIGNED/LITTLE을 의미한다.


표 6: UMAC의 안전성
UMAC-OUTPUT-LEN(bytes) UMAC의 위조 확률
2 $ 2^{-15}$
4 $ 2^{-30}$
8 $ 2^{-60}$
16 $ 2^{-120}$


그러면 UMAC은 다음과 같은 과정으로 구한다.

  • INPUT :

    $ K$ : key string of length UMAC-KEY-LEN bytes.
    $ M$ : message string of length less than $ 2^{64}$ bytes.
    $ Nonce$ : nonce string of length 1 to 16 bytes.

  • OUTPUT :

    $ AuthTag$ : string of length UMAC-OUTPUT-LEN bytes.

  • STEPS :
    1. begin{displaymath}HashedMessage = begin{cases} mbox{UHASH-32}(K,M), & mbox{i... ...UHASH-16}(K,M), & mbox{if } mbox{tt WORD-LEN}=2. end{cases}end{displaymath}
    2. $ Pad = {rm PDF}(K, Nonce)$.
    3. $ AuthTag = Pad oplus HashedMessage$.

UHASH함수는 임의의 길이의 입력 메세지에 대하여 사용자 키 $ K$를 가지고 UMAC-OUTPUT-LEN의 길이로 출력하는 함수(UHASH-32는 32 비트 word size 프로세서에 적용되며 UHASH-16은 16 비트 word size 프로세서에 적용되는 함수). 다음의 3 계층으로 이루어진다.

  • L1-HASH
  • L2-HASH
  • L3-HASH

키 $ K$로 부터 새로운 키 블럭을 유도하여 3 계층을 거치면 word size만큼의 결과를 출력한다. 원하는 UMAC-OUTPUT-LEN 바이트의 길이가 될때까지 새로운 키 블럭을 유도하여 3 계층이 반복적으로 적용한 결과를 연접한다.

L1-HASH-32는 메세지 $ M$을 L1-KEY-LEN 바이트 단위로 나누어 각 단위 메세지를 NH-32(아래 그림 참조)에 적용 8 바이트를 얻고 이것을 차례로 연접시킨다.

그림 12: NH-32

L1-HASH-32가 여전히 상대적으로 긴 출력을 가지므로 L2-HASH-32는 'polynomial hash function' POLY를 이용하여 16 바이트의 고정된 길이로 압축한다.

L2-HASH-32 함수를 통하여 16 바이트의 고정된 길이로 압축되면 L3-HASH-32를 거쳐서 마지막으로 32 비트의 최종 결과를 얻는다.

이와같이 UMAC은 MAC을 생성할 때, UHASH-32에서 $ HashedMessage$가 32 비트 단위로 차례로 구해지므로 MAC의 앞부분만을 이용하여 검증할 수도 있다.

UHASH-16은 WORD-LEN=2이므로 UHASH-32와는 기본단위가 다르므로 알고리즘이 차이가 나지만 기본적인 알고리즘의 구조는 거의 유사하다

L1-HASH-16은 NH-16 함수를 이용하여 메세지 $ M$을 압축하는 단계로 UMAC-OUTPUT-LEN보다는 긴 길이로 압축한다. NH-16 역시 NH-32와 같이 32 바이트의 배수가 되는 메세지 $ M$을 입력으로 하지만 8 바이트가 아니라 4 바이트의 출력을 내는 함수이다.

그림 13: NH-16

L2-HASH-16도 L2-HASH-32에서와 같은 `polynomial hash function' POLY를 이용하여 16 바이트의 고정된 길이로 압축한다. L3-HASH-16은 L2-HASH-16의 출력인 16 바이트로부터 16 비트를 출력하는 함수이다.



=--------------------------------------------------------------------------------------=

This document was generated using the LaTeX2HTML translator Version 99.2beta8 (1.43)

Copyright © 1993, 1994, 1995, 1996, Nikos Drakos, Computer Based Learning Unit, University of Leeds.
Copyright © 1997, 1998, 1999, Ross Moore, Mathematics Department, Macquarie University, Sydney.

The command line arguments were:
latex2html summary

The translation was initiated by 이동훈 on 2001-06-07
AND

티스토리툴바