Kerberos (protocol)

[운영자]

http://publib.boulder.ibm.com/html/as400/v5r1/ic2986/info/rzakh/rzakha06.htm#WhatKerberosDoes

Kerberos (protocol)

From Wikipedia, the free encyclopedia

위키피디아로 부터, 자유로운 백과사전 

Jump to: navigation, search (건너띄기:목차,검색)

This article is about the security protocol. For other uses, see Kerberos.

보안 프로토콜과 관련된 논설입니다.

Stable release	krb5-1.9.2 / November 2, 2011; 41 days ago (2011-11-02)
Website	web.mit.edu/kerberos/

Kerberos ( /ˈkɛərbərəs/) is a computer network authentication protocol which works on the basis of "tickets" to allow nodes communicating over a non-secure network to prove their identity to one another in a secure manner.

커버러스는 개방된 네트워크상에서 안전한 방법으로 각 자신의 신분을 증명하기위해서 노드들의 통신을 허용 하는 "티켓"을 바탕으로 동작하는 컴퓨터 네트워크 인증 프로토콜이다.  

Its designers aimed primarily at a client–server model,

이 프로토콜은 클라이언트&서버 모델을 겨냥하여 디자인 되었다.

and it provides mutual authentication—both the user and the server verify each other's identity.

또한 상호인증을 제공한다-유저와 서버 모두 각자의 신분을 인증함

Kerberos protocol messages are protected against eavesdropping and replay attacks.

커버로스 프로토콜 메지시들은 도청과 리플레이 공격에 보호 된다.

Kerberos builds on symmetric key cryptography and requires a trusted third party,

커버로스는 대칭 키 암호법 상에 구축되었고 제3 신뢰 기관을 요구한다.

and optionally may use public-key cryptography by utilizing asymmetric key cryptography during certain phases of authentication.^[1] Kerberos uses port 88 by default.

그리고 선택적으로 인증의 단계 중 비대칭 키 암호법을 활용한 공개키 암호법을 사용한다. 커버러스는 기본적으로 88번 보트를 사용한다.

"Kerberos" also refers to a suite of free software published by Massachusetts Institute of Technology (MIT) that implements the Kerberos protocol.

"커버로스"는 또한 커버러스 프로토콜을 구현한 메사추세츠 공과 대학에 의해 자유 소프트웨어로 발행되었다.

Contents(목차)

 [hide] //숨기기

• 1 History and development //역사와 성장
• 2 Protocol (통신규약)
  • 2.1 Theory (이론)
  • 2.2 Description (해설)
    • 2.2.1 User Client-based Logon (클라이언트 기반의 사용자 로그온)
    • 2.2.2 Client Authentication (클라이언트 인증)
    • 2.2.3 Client Service Authorization (클라이언트 서비스 권한부여)
    • 2.2.4 Client Service Request (클라이언트 서비스 요청)
• 3 Drawbacks and Limitations (장애와 제한)
• 4 Related Requests For Comments (논평에대한 관계요구?)
• 5 See also (그밖에)
• 6 References (참고)
• 7 External links (외부링크들)

[edit] History and development(역사와 발전)

MIT developed Kerberos to protect network services provided by Project Athena.

MIT는 '아테나'프로젝트에 의해 제공된 네트워크 서비스 보호를 위해 커버로스를 개발했다.

The protocol was named after the Greek mythological character Kerberos (or Cerberus),

프로토콜이름은 그리스 신화의 캐릭터 커버러스(또는 서버러스)를 본따 지어졌으며.

known in Greek mythology as being the monstrous three-headed guard dog of Hades.

커버러스는 그리스 신화에 나오는 하데스의 머리가 세개달린 경비견으로 알려져있다.

Several versions of the protocol exist; versions 1–3 occurred only internally at MIT.

여러가지의 프로토콜 버전이 존재함;1-3까지의 버전들은 MIT 내부에서만 존재했다.

Steve Miller and Clifford Neuman, the primary designers of Kerberos version 4, published that version in the late 1980s, although they had targeted it primarily for Project Athena.

스티브밀러와 클리포드 뉴먼은(커버러스 버전 4의 근본적인 디자이너들), 1980년대 말에 커버러스 버전4를 발표했다.비록 그들은 아테나프로젝트를 주 목표로 했지만,,,

Version 5, designed by John Kohl and Clifford Neuman, appeared as RFC 1510 in 1993 (made obsolete by RFC 4120 in 2005), with the intention of overcoming the limitations and security problems of version 4.

버전 5는 존 콜과 클리포드 뉴먼에 의해 디자인되었다(1993년 RFC 1510으로 출현함(2005년 RFC 4120에 의해 무용지물이 되어버렸지만)), 이것은 버전 4의 한계점과 보안문제들을 극복할 목적으로 디자인 된 것이다.

MIT makes an implementation of Kerberos freely available,under copyright permissions similar to those used for BSD.

MIT는 BSD의 사용되어지는 것과 유사한 저작권하에서, 커버러스의 구현을 자유롭게 이용할수 있도록 하였다.

In 2007,

2007년에,

MIT formed the Kerberos Consortium to foster continued development.

MIT는 지속적인 발전을 촉진시키기 위해 커버러스 컨소시엄을 세웠다.

Founding sponsors include vendors such as Oracle, Apple Inc., Google, Microsoft, Centrify Corporation and TeamF1 Inc., and academic institutions such as KTH-Royal Institute of Technology, Stanford University, MIT and vendors such as CyberSafe offering commercially supported versions.

설립 후원자들로는 오라클, 애플, 구글, 마이크로소프트, 센트리피 회사와 팀F1 밴더들..그리고 KTH-Royal 기술 기관, 스탠포드 대학 MIT와 같은 학술기관들, 상업적으로 하는 버전들을 판매하기 위한 사이버세이프와 같은 벤더들이 설립후원자로 포함되어 있다.

Authorities in the United States classified Kerberos as auxiliary military technology and banned its export because it used the DES encryption algorithm (with 56-bit keys).

미당국은(미국은) 커버러스를 보조 군사 기술로 분류하였으며 이것에 대한 수출을 금지하였다. 왜냐하면 이것은 DES암호화 알고리즘(56비트 키를 사용함)을 사용하였기 때문이다.[DES암호화알고리즘을 쓰는데 왜 수출을 금지하지;??;;]

A non-US Kerberos 4 implementation,

비 US 커버러스 4 구현은,

KTH-KRB developed at the Royal Institute of Technology in Sweden,

KTH-KRB가 스웨덴에 있는 로얄 기술 연구소에서 개발하였다.

made the system available outside the US before the US changed its cryptography export regulations (circa 2000). The Swedish implementation was based on a limited version called eBones. eBones was based on the exported MIT Bones release (stripped of both the encryption functions and the calls to them) based on version Kerberos 4 patch-level 9.

Windows 2000 and later use Kerberos as their default authentication method. Some Microsoft additions to the Kerberos suite of protocols are documented in RFC 3244 "Microsoft Windows 2000 Kerberos Change Password and Set Password Protocols". RFC 4757 documents Microsoft's use of the RC4 cipher. While Microsoft uses the Kerberos protocol, it does not use the MIT software.

Many UNIX and UNIX-like operating systems, including FreeBSD, Apple's Mac OS X, Red Hat Enterprise Linux 4, Oracle's Solaris, IBM's AIX, HP's OpenVMS, and others, include software for Kerberos authentication of users or services. Embedded implementation of the Kerberos V authentication protocol for client agents and network services running on embedded platforms is also available from companies such as TeamF1, Inc.

As of 2005^[update], the IETF Kerberos working group is updating the specifications. Recent updates include:

• Encryption and Checksum Specifications" (RFC 3961).
• Advanced Encryption Standard (AES) Encryption for Kerberos 5 (RFC 3962).
• A new edition of the Kerberos V5 specification "The Kerberos Network Authentication Service (V5)" (RFC 4120). This version obsoletes RFC 1510, clarifies aspects of the protocol and intended use in a more detailed and clearer explanation.
• A new edition of the GSS-API specification "The Kerberos Version 5 Generic Security Service Application Program Interface (GSS-API) Mechanism: Version 2." (RFC 4121).

[edit] Protocol

This section requires expansion.

[edit] Theory

Kerberos uses as its basis the symmetric Needham-Schroeder protocol. It makes use of a trusted third party, termed a key distribution center (KDC), which consists of two logically separate parts: an Authentication Server (AS) and a Ticket Granting Server (TGS).

The KDC maintains a database of secret keys; each entity on the network — whether a client or a server — shares a secret key known only to itself and to the KDC. Knowledge of this key serves to prove an entity's identity. For communication purposes the KDC generates a session key which communicating parties use to encrypt their transmissions.

The security of the protocol relies heavily on short-lived assertions of authenticity called Kerberos tickets.

[edit] Description

The client authenticates itself to the AS which forwards the username to a Key Distribution Center (KDC). The KDC issues a Ticket Granting Ticket (TGT), which is time stamped, encrypts it using the user's password and returns the encrypted result to the user's workstation. If successful, this gives the user desktop access.

When the client needs to communicate with another node ("principal" in Kerberos parlance) it sends the TGT to the Ticket Granting Service (TGS), which shares the same host as the TGT. After verifying the TGT is valid and the user is permitted to access the requested service, the TGS issues a Ticket and session keys, which are returned to the client.

The client then sends the Ticket and keys to the service (SS).

Kerberos negotiations

Here is another description.

The client authenticates to the AS once using a long-term shared secret (e.g. a password) and receives a Ticket Granting Ticket (TGT) from the AS. Later, when the client wants to contact some SS, it can (re)use this ticket to get additional tickets from TGS, for SS, without resorting to using the shared secret. The latter tickets can be used to prove authentication to the SS.

The phases are detailed below.

[edit] User Client-based Logon

1. A user enters a username and password on the client machine.
2. The client performs a one-way function (hash usually) on the entered password, and this becomes the secret key of the client/user.

[edit] Client Authentication

Kerberos Protocol

1. The client sends a cleartext message of the user ID to the AS requesting services on behalf of the user. (Note: Neither the secret key nor the password is sent to the AS.) The AS generates the secret key by hashing the password of the user found at the database (e.g. Active Directory in Windows Server).
2. The AS checks to see if the client is in its database. If it is, the AS sends back the following two messages to the client:
   • Message A: Client/TGS Session Key encrypted using the secret key of the client/user.
   • Message B: Ticket-Granting-Ticket (which includes the client ID, client network address, ticket validity period, and the client/TGS session key) encrypted using the secret key of the TGS.
3. Once the client receives messages A and B, it attempts to decrypt message A with the secret key generated from the password entered by the user. If the user entered password does not match the password in the AS database, the client's secret key will be different and thus unable to decrypt message A. With a valid password and secret key the client decrypts message A to obtain the Client/TGS Session Key. This session key is used for further communications with the TGS. (Note: The client cannot decrypt Message B, as it is encrypted using TGS's secret key.) At this point, the client has enough information to authenticate itself to the TGS.

[edit] Client Service Authorization

1. When requesting services, the client sends the following two messages to the TGS:
   • Message C: Composed of the TGT from message B and the ID of the requested service.
   • Message D: Authenticator (which is composed of the client ID and the timestamp), encrypted using the Client/TGS Session Key.
2. Upon receiving messages C and D, the TGS retrieves message B out of message C. It decrypts message B using the TGS secret key. This gives it the "client/TGS session key". Using this key, the TGS decrypts message D (Authenticator) and sends the following two messages to the client:
   • Message E: Client-to-server ticket (which includes the client ID, client network address, validity period and Client/Server Session Key) encrypted using the service's secret key.
   • Message F: Client/server session key encrypted with the Client/TGS Session Key.

[edit] Client Service Request

1. Upon receiving messages E and F from TGS, the client has enough information to authenticate itself to the SS. The client connects to the SS and sends the following two messages:
   • Message E from the previous step (the client-to-server ticket, encrypted using service's secret key).
   • Message G: a new Authenticator, which includes the client ID, timestamp and is encrypted using client/server session key.
2. The SS decrypts the ticket using its own secret key to retrieve the Client/Server Session Key. Using the sessions key, SS decrypts the Authenticator and sends the following message to the client to confirm‎ its true identity and willingness to serve the client:
   • Message H: the timestamp found in client's Authenticator plus 1, encrypted using the Client/Server Session Key.
3. The client decrypts the confirmation using the Client/Server Session Key and checks whether the timestamp is correctly updated. If so, then the client can trust the server and can start issuing service requests to the server.
4. The server provides the requested services to the client.

[edit] Drawbacks and Limitations

• Single point of failure: It requires continuous availability of a central server. When the Kerberos server is down, no one can log in. This can be mitigated by using multiple Kerberos servers and fallback authentication mechanisms.
• Kerberos has strict time requirements, which means the clocks of the involved hosts must be synchronized within configured limits. The tickets have a time availability period and if the host clock is not synchronized with the Kerberos server clock, the authentication will fail. The default configuration per MIT requires that clock times are no more than five minutes apart. In practice Network Time Protocol daemons are usually used to keep the host clocks synchronized.
• The administration protocol is not standardized and differs between server implementations. Password changes are described in RFC 3244.
• Since all authentication is controlled by a centralized KDC, compromise of this authentication infrastructure will allow an attacker to impersonate any user.

[edit] Related Requests For Comments